--- /dev/null
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/.travis.yml
+@@ -0,0 +1,44 @@
++language: cpp
++matrix:
++ include:
++ - env: toolset=gcc
++ - os: osx
++ osx_image: xcode11.2
++ env: toolset=darwin
++
++branches:
++ only:
++ - master
++
++git:
++ submodules: false
++ depth: 1
++
++addons:
++ apt:
++ sources:
++ - ubuntu-toolchain-r-test
++ packages:
++ - libboost-tools-dev
++ - g++-9
++
++install:
++
++ - 'if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update > /dev/null && brew install boost-build; fi'
++ - 'if [[ $TRAVIS_OS_NAME != "osx" ]]; then
++ export B2=bjam;
++ else
++ export B2=b2;
++ fi'
++ - touch ~/user-config.jam
++ - 'if [[ $toolset == "gcc" ]]; then
++ g++-5 --version;
++ echo "using gcc : : g++-5 : <cxxflags>-std=c++11 ;" >> ~/user-config.jam;
++ fi'
++ - 'echo "using darwin : : clang++ : <cxxflags>-std=c++11 ;" >> ~/user-config.jam'
++
++script:
++
++ - ${B2} link=static stage_test
++ - ./test
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/CMakeLists.txt
+@@ -0,0 +1,6 @@
++cmake_minimum_required(VERSION 2.8.12)
++project(try_signal)
++
++add_library(try_signal signal_error_code try_signal)
++target_include_directories(try_signal PUBLIC .)
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/Jamfile
+@@ -0,0 +1,18 @@
++lib try_signal
++ : # sources
++ signal_error_code.cpp try_signal.cpp
++ : # requirements
++ : # default build
++ <link>static
++ : # usage requirements
++ <include>.
++ ;
++
++exe test : test.cpp : <library>try_signal <link>static ;
++explicit test ;
++
++exe example : example.cpp : <library>try_signal <link>static ;
++explicit example ;
++
++install stage_test : test : <location>. ;
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/LICENSE
+@@ -0,0 +1,29 @@
++BSD 3-Clause License
++
++Copyright (c) 2016, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions are met:
++
++* Redistributions of source code must retain the above copyright notice, this
++ list of conditions and the following disclaimer.
++
++* Redistributions in binary form must reproduce the above copyright notice,
++ this list of conditions and the following disclaimer in the documentation
++ and/or other materials provided with the distribution.
++
++* Neither the name of the copyright holder nor the names of its
++ contributors may be used to endorse or promote products derived from
++ this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
++FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
++SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
++CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
++OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/README.rst
+@@ -0,0 +1,53 @@
++try_signal
++==========
++
++.. image:: https://travis-ci.org/arvidn/try_signal.svg?branch=master
++ :target: https://travis-ci.org/arvidn/try_signal
++
++.. image:: https://ci.appveyor.com/api/projects/status/le8jjroaai8081f1?svg=true
++ :target: https://ci.appveyor.com/project/arvidn/try-signal/branch/master
++
++The ``try_signal`` library provide a way to turn signals into C++ exceptions.
++This is especially useful when performing disk I/O via memory mapped files,
++where I/O errors are reported as ``SIGBUS`` and ``SIGSEGV`` or as structured
++exceptions on windows.
++
++The function ``try_signal`` takes a function object that will be executed once.
++If the function causes a signal (or structured exception) to be raised, it will
++throw a C++ exception. Note that RAII may not be relied upon within this function.
++It may not rely on destructors being called. Stick to simple operations like
++memcopy.
++
++Example::
++
++ #include <stdexcept>
++ #include <vector>
++ #include <numeric>
++ #include "try_signal.hpp"
++ #include <fcntl.h>
++ #include <unistd.h>
++ #include <sys/mman.h>
++
++ int main() try
++ {
++ int fd = open("test_file", O_RDWR);
++ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
++
++ std::vector<char> buf(1024);
++ std::iota(buf.begin(), buf.end(), 0);
++
++ // disk full or access after EOF are reported as exceptions
++ sig::try_signal([&]{
++ std::memcpy(map, buf.data(), buf.size());
++ });
++
++ munmap(map, 1024);
++ close(fd);
++ return 0;
++ }
++ catch (std::exception const& e)
++ {
++ fprintf(stderr, "exited with exception: %s\n", e.what());
++ return 1;
++ }
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/appveyor.yml
+@@ -0,0 +1,50 @@
++version: "{build}"
++branches:
++ only:
++ - master
++os: Visual Studio 2015
++clone_depth: 1
++environment:
++ matrix:
++ - variant: debug
++ compiler: msvc-14.0
++ model: 64
++ - variant: debug
++ compiler: msvc-14.0
++ model: 32
++ - variant: release
++ compiler: msvc-14.0
++ model: 64
++ - variant: debug
++ compiler: gcc
++ model: 32
++ - variant: debug
++ compiler: gcc
++ model: 64
++ - variant: release
++ compiler: gcc
++ model: 32
++
++install:
++- set ROOT_DIRECTORY=%CD%
++- set BOOST_ROOT=c:\Libraries\boost_1_67_0
++- set BOOST_BUILD_PATH=%BOOST_ROOT%\tools\build
++- echo %BOOST_ROOT%
++- echo %BOOST_BUILD_PATH%
++- set PATH=%PATH%;%BOOST_BUILD_PATH%\src\engine\bin.ntx86
++- ps: '"using msvc : 14.0 ;`nusing gcc : : : <cxxflags>-std=c++11 ;" | Set-Content $env:HOMEDRIVE\$env:HOMEPATH\user-config.jam'
++- type %HOMEDRIVE%%HOMEPATH%\user-config.jam
++- set PATH=c:\msys64\mingw32\bin;%PATH%
++- g++ --version
++- python --version
++- echo %ROOT_DIRECTORY%
++- cd %BOOST_BUILD_PATH%\src\engine
++- build.bat >nul
++- cd %ROOT_DIRECTORY%
++
++build_script:
++# examples
++- b2.exe warnings=all warnings-as-errors=on -j2 %compiler% address-model=%model% variant=%variant% stage_test
++
++test_script:
++- test
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/example.cpp
+@@ -0,0 +1,31 @@
++#include <stdexcept>
++#include <vector>
++#include <numeric>
++#include "try_signal.hpp"
++#include <fcntl.h>
++#include <unistd.h>
++#include <sys/mman.h>
++
++int main() try
++{
++ int fd = open("test_file", O_RDWR);
++ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
++
++ std::vector<char> buf(1024);
++ std::iota(buf.begin(), buf.end(), 0);
++
++ // disk full or access after EOF are reported as exceptions
++ sig::try_signal([&]{
++ std::memcpy(map, buf.data(), buf.size());
++ });
++
++ munmap(map, 1024);
++ close(fd);
++ return 0;
++}
++catch (std::exception const& e)
++{
++ fprintf(stderr, "exited with exception: %s\n", e.what());
++ return 1;
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/signal_error_code.cpp
+@@ -0,0 +1,209 @@
++/*
++
++Copyright (c) 2016, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#include <system_error>
++#include <string>
++
++#include "signal_error_code.hpp"
++
++namespace {
++
++ struct signal_error_category : std::error_category
++ {
++ const char* name() const noexcept override
++ { return "signal"; }
++ std::string message(int ev) const noexcept override
++ {
++#define SIGNAL_CASE(x) case sig::errors::error_code_enum:: x: return #x;
++ switch (ev)
++ {
++ SIGNAL_CASE(abort)
++ SIGNAL_CASE(alarm)
++ SIGNAL_CASE(arithmetic_exception)
++ SIGNAL_CASE(hangup)
++ SIGNAL_CASE(illegal)
++ SIGNAL_CASE(interrupt)
++ SIGNAL_CASE(kill)
++ SIGNAL_CASE(pipe)
++ SIGNAL_CASE(quit)
++ case sig::errors::error_code_enum::segmentation: return "segmentation fault";
++ SIGNAL_CASE(terminate)
++ SIGNAL_CASE(user1)
++ SIGNAL_CASE(user2)
++ SIGNAL_CASE(child)
++ SIGNAL_CASE(cont)
++ SIGNAL_CASE(stop)
++ SIGNAL_CASE(terminal_stop)
++ SIGNAL_CASE(terminal_in)
++ SIGNAL_CASE(terminal_out)
++ SIGNAL_CASE(bus)
++#ifdef SIGPOLL
++ SIGNAL_CASE(poll)
++#endif
++ SIGNAL_CASE(profiler)
++ SIGNAL_CASE(system_call)
++ SIGNAL_CASE(trap)
++ SIGNAL_CASE(urgent_data)
++ SIGNAL_CASE(virtual_timer)
++ SIGNAL_CASE(cpu_limit)
++ SIGNAL_CASE(file_size_limit)
++ default: return "unknown";
++ }
++#undef SIGNAL_CASE
++ }
++ std::error_condition default_error_condition(int ev) const noexcept override
++ { return {ev, *this}; }
++ };
++} // anonymous namespace
++
++namespace sig {
++namespace errors {
++
++ std::error_code make_error_code(error_code_enum e)
++ {
++ return {e, sig_category()};
++ }
++
++ std::error_condition make_error_condition(error_code_enum e)
++ {
++ return {e, sig_category()};
++ }
++
++} // namespace errors
++
++std::error_category& sig_category()
++{
++ static signal_error_category signal_category;
++ return signal_category;
++}
++
++#ifdef _WIN32
++
++namespace {
++ sig::errors::error_code_enum map_exception_code(int const ev)
++ {
++ switch (ev)
++ {
++ case seh_errors::error_code_enum::access_violation:
++ case seh_errors::error_code_enum::array_bounds_exceeded:
++ case seh_errors::error_code_enum::guard_page:
++ case seh_errors::error_code_enum::stack_overflow:
++ case seh_errors::error_code_enum::flt_stack_check:
++ case seh_errors::error_code_enum::in_page_error:
++ return sig::errors::segmentation;
++ case seh_errors::error_code_enum::breakpoint:
++ case seh_errors::error_code_enum::single_step:
++ return sig::errors::trap;
++ case seh_errors::error_code_enum::datatype_misalignment:
++ return sig::errors::bus;
++ case seh_errors::error_code_enum::flt_denormal_operand:
++ case seh_errors::error_code_enum::flt_divide_by_zero:
++ case seh_errors::error_code_enum::flt_inexact_result:
++ case seh_errors::error_code_enum::flt_invalid_operation:
++ case seh_errors::error_code_enum::flt_overflow:
++ case seh_errors::error_code_enum::flt_underflow:
++ case seh_errors::error_code_enum::int_divide_by_zero:
++ case seh_errors::error_code_enum::int_overflow:
++ return sig::errors::arithmetic_exception;
++ case seh_errors::error_code_enum::illegal_instruction:
++ case seh_errors::error_code_enum::invalid_disposition:
++ case seh_errors::error_code_enum::priv_instruction:
++ case seh_errors::error_code_enum::noncontinuable_exception:
++ case seh_errors::error_code_enum::status_unwind_consolidate:
++ return sig::errors::illegal;
++ case seh_errors::error_code_enum::invalid_handle:
++ return sig::errors::pipe;
++ default:
++ return sig::errors::illegal;
++ }
++ }
++
++ struct seh_error_category : std::error_category
++ {
++ const char* name() const noexcept override
++ { return "SEH"; }
++ std::string message(int ev) const noexcept override
++ {
++#define SIGNAL_CASE(x) case sig::seh_errors::error_code_enum:: x: return #x;
++ switch (ev)
++ {
++ SIGNAL_CASE(access_violation)
++ SIGNAL_CASE(array_bounds_exceeded)
++ SIGNAL_CASE(guard_page)
++ SIGNAL_CASE(stack_overflow)
++ SIGNAL_CASE(flt_stack_check)
++ SIGNAL_CASE(in_page_error)
++ SIGNAL_CASE(breakpoint)
++ SIGNAL_CASE(single_step)
++ SIGNAL_CASE(datatype_misalignment)
++ SIGNAL_CASE(flt_denormal_operand)
++ SIGNAL_CASE(flt_divide_by_zero)
++ SIGNAL_CASE(flt_inexact_result)
++ SIGNAL_CASE(flt_invalid_operation)
++ SIGNAL_CASE(flt_overflow)
++ SIGNAL_CASE(flt_underflow)
++ SIGNAL_CASE(int_divide_by_zero)
++ SIGNAL_CASE(int_overflow)
++ SIGNAL_CASE(illegal_instruction)
++ SIGNAL_CASE(invalid_disposition)
++ SIGNAL_CASE(priv_instruction)
++ SIGNAL_CASE(noncontinuable_exception)
++ SIGNAL_CASE(status_unwind_consolidate)
++ SIGNAL_CASE(invalid_handle)
++ default: return "unknown";
++ }
++#undef SIGNAL_CASE
++ }
++ std::error_condition default_error_condition(int ev) const noexcept override
++ { return std::error_condition(map_exception_code(ev), sig_category()); }
++ };
++} // anonymous namespace
++
++namespace seh_errors {
++
++ std::error_code make_error_code(error_code_enum e)
++ {
++ return {static_cast<int>(e), seh_category()};
++ }
++
++} // namespace errors
++
++std::error_category& seh_category()
++{
++ static seh_error_category seh_category;
++ return seh_category;
++}
++
++#endif
++
++} // namespace sig
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/signal_error_code.hpp
+@@ -0,0 +1,162 @@
++/*
++
++Copyright (c) 2016, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifndef SIGNAL_ERROR_CODE_HPP_INCLUDED
++#define SIGNAL_ERROR_CODE_HPP_INCLUDED
++
++#include <signal.h>
++#include <system_error>
++
++#ifdef _WIN32
++#ifndef WIN32_LEAN_AND_MEAN
++#define WIN32_LEAN_AND_MEAN
++#endif
++#include <windows.h>
++
++#ifdef __GNUC__
++#include <excpt.h>
++#else
++#include <eh.h>
++#endif
++#endif
++
++namespace sig {
++namespace errors {
++
++#ifdef _WIN32
++#define SIG_ENUM(name, sig) name,
++#else
++#define SIG_ENUM(name, sig) name = sig,
++#endif
++
++ enum error_code_enum: int
++ {
++ SIG_ENUM(abort, SIGABRT)
++ SIG_ENUM(alarm, SIGALRM)
++ SIG_ENUM(arithmetic_exception, SIGFPE)
++ SIG_ENUM(hangup, SIGHUP)
++ SIG_ENUM(illegal, SIGILL)
++ SIG_ENUM(interrupt, SIGINT)
++ SIG_ENUM(kill, SIGKILL)
++ SIG_ENUM(pipe, SIGPIPE)
++ SIG_ENUM(quit, SIGQUIT)
++ SIG_ENUM(segmentation, SIGSEGV)
++ SIG_ENUM(terminate, SIGTERM)
++ SIG_ENUM(user1, SIGUSR1)
++ SIG_ENUM(user2, SIGUSR2)
++ SIG_ENUM(child, SIGCHLD)
++ SIG_ENUM(cont, SIGCONT)
++ SIG_ENUM(stop, SIGSTOP)
++ SIG_ENUM(terminal_stop, SIGTSTP)
++ SIG_ENUM(terminal_in, SIGTTIN)
++ SIG_ENUM(terminal_out, SIGTTOU)
++ SIG_ENUM(bus, SIGBUS)
++#ifdef SIGPOLL
++ SIG_ENUM(poll, SIGPOLL)
++#endif
++ SIG_ENUM(profiler, SIGPROF)
++ SIG_ENUM(system_call, SIGSYS)
++ SIG_ENUM(trap, SIGTRAP)
++ SIG_ENUM(urgent_data, SIGURG)
++ SIG_ENUM(virtual_timer, SIGVTALRM)
++ SIG_ENUM(cpu_limit, SIGXCPU)
++ SIG_ENUM(file_size_limit, SIGXFSZ)
++ };
++
++#undef SIG_ENUM
++
++ std::error_code make_error_code(error_code_enum e);
++ std::error_condition make_error_condition(error_code_enum e);
++
++} // namespace errors
++
++std::error_category& sig_category();
++
++#ifdef _WIN32
++namespace seh_errors {
++
++ // standard error codes are "int", the win32 exceptions are DWORD (i.e.
++ // unsigned int). We coerce them into int here for compatibility, and we're
++ // not concerned about their arithmetic
++ enum error_code_enum: int
++ {
++ access_violation = int(EXCEPTION_ACCESS_VIOLATION),
++ array_bounds_exceeded = int(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
++ guard_page = int(EXCEPTION_GUARD_PAGE),
++ stack_overflow = int(EXCEPTION_STACK_OVERFLOW),
++ flt_stack_check = int(EXCEPTION_FLT_STACK_CHECK),
++ in_page_error = int(EXCEPTION_IN_PAGE_ERROR),
++ breakpoint = int(EXCEPTION_BREAKPOINT),
++ single_step = int(EXCEPTION_SINGLE_STEP),
++ datatype_misalignment = int(EXCEPTION_DATATYPE_MISALIGNMENT),
++ flt_denormal_operand = int(EXCEPTION_FLT_DENORMAL_OPERAND),
++ flt_divide_by_zero = int(EXCEPTION_FLT_DIVIDE_BY_ZERO),
++ flt_inexact_result = int(EXCEPTION_FLT_INEXACT_RESULT),
++ flt_invalid_operation = int(EXCEPTION_FLT_INVALID_OPERATION),
++ flt_overflow = int(EXCEPTION_FLT_OVERFLOW),
++ flt_underflow = int(EXCEPTION_FLT_UNDERFLOW),
++ int_divide_by_zero = int(EXCEPTION_INT_DIVIDE_BY_ZERO),
++ int_overflow = int(EXCEPTION_INT_OVERFLOW),
++ illegal_instruction = int(EXCEPTION_ILLEGAL_INSTRUCTION),
++ invalid_disposition = int(EXCEPTION_INVALID_DISPOSITION),
++ priv_instruction = int(EXCEPTION_PRIV_INSTRUCTION),
++ noncontinuable_exception = int(EXCEPTION_NONCONTINUABLE_EXCEPTION),
++ status_unwind_consolidate = int(STATUS_UNWIND_CONSOLIDATE),
++ invalid_handle = int(EXCEPTION_INVALID_HANDLE),
++ };
++
++ std::error_code make_error_code(error_code_enum e);
++}
++
++std::error_category& seh_category();
++
++#endif // _WIN32
++
++} // namespace sig
++
++namespace std
++{
++template<>
++struct is_error_code_enum<sig::errors::error_code_enum> : std::true_type {};
++
++template<>
++struct is_error_condition_enum<sig::errors::error_code_enum> : std::true_type {};
++
++#ifdef _WIN32
++template<>
++struct is_error_code_enum<sig::seh_errors::error_code_enum> : std::true_type {};
++#endif
++
++} // namespace std
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/test.cpp
+@@ -0,0 +1,47 @@
++#include <stdexcept>
++#include <array>
++#include <cstring> // for memcpy
++
++#include "try_signal.hpp"
++
++int main()
++{
++ char const buf[] = "test...test";
++ char dest[sizeof(buf)];
++
++ {
++ sig::try_signal([&]{
++ std::memcpy(dest, buf, sizeof(buf));
++ });
++ if (!std::equal(buf, buf + sizeof(buf), dest)) {
++ fprintf(stderr, "ERROR: buffer not copied correctly\n");
++ return 1;
++ }
++ }
++
++ try {
++ void* invalid_pointer = nullptr;
++ sig::try_signal([&]{
++ std::memcpy(dest, buf, sizeof(buf));
++ std::memcpy(dest, invalid_pointer, sizeof(buf));
++ });
++ }
++ catch (std::system_error const& e)
++ {
++ if (e.code() != std::error_condition(sig::errors::segmentation)) {
++ fprintf(stderr, "ERROR: expected segmentaiton violation error\n");
++ }
++ else {
++ fprintf(stderr, "OK\n");
++ }
++ fprintf(stderr, "exited with expected system_error exception: %s\n", e.what());
++
++ // we expect this to happen, so return 0
++ return e.code() == std::error_condition(sig::errors::segmentation) ? 0 : 1;
++ }
++
++ // return non-zero here because we don't expect this
++ fprintf(stderr, "ERROR: expected exit through exception\n");
++ return 1;
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal.cpp
+@@ -0,0 +1,144 @@
++/*
++
++Copyright (c) 2016, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#include <cassert>
++#include <system_error>
++#include <atomic>
++#include <csetjmp>
++#include <csignal>
++
++#include "try_signal.hpp"
++
++#if !defined _WIN32
++// linux
++
++namespace sig {
++namespace detail {
++
++namespace {
++thread_local sigjmp_buf* jmpbuf = nullptr;
++}
++
++std::atomic_flag once = ATOMIC_FLAG_INIT;
++
++scoped_jmpbuf::scoped_jmpbuf(sigjmp_buf* ptr)
++{
++ _previous_ptr = jmpbuf;
++ jmpbuf = ptr;
++ std::atomic_signal_fence(std::memory_order_release);
++}
++
++scoped_jmpbuf::~scoped_jmpbuf() { jmpbuf = _previous_ptr; }
++
++void handler(int const signo, siginfo_t*, void*)
++{
++ std::atomic_signal_fence(std::memory_order_acquire);
++ if (jmpbuf)
++ siglongjmp(*jmpbuf, signo);
++
++ // this signal was not caused within the scope of a try_signal object,
++ // invoke the default handler
++ signal(signo, SIG_DFL);
++ raise(signo);
++}
++
++void setup_handler()
++{
++ struct sigaction sa;
++ sa.sa_sigaction = &sig::detail::handler;
++ sigemptyset(&sa.sa_mask);
++ sa.sa_flags = SA_SIGINFO;
++ sigaction(SIGSEGV, &sa, nullptr);
++ sigaction(SIGBUS, &sa, nullptr);
++}
++
++} // detail namespace
++} // sig namespace
++
++#elif __GNUC__
++// mingw
++
++#ifndef WIN32_LEAN_AND_MEAN
++#define WIN32_LEAN_AND_MEAN
++#endif
++#include <windows.h>
++
++namespace sig {
++namespace detail {
++
++thread_local jmp_buf* jmpbuf = nullptr;
++
++long CALLBACK handler(EXCEPTION_POINTERS* pointers)
++{
++ std::atomic_signal_fence(std::memory_order_acquire);
++ if (jmpbuf)
++ longjmp(*jmpbuf, pointers->ExceptionRecord->ExceptionCode);
++ return EXCEPTION_CONTINUE_SEARCH;
++}
++
++scoped_handler::scoped_handler(jmp_buf* ptr)
++{
++ _previous_ptr = jmpbuf;
++ jmpbuf = ptr;
++ std::atomic_signal_fence(std::memory_order_release);
++ _handle = AddVectoredExceptionHandler(1, sig::detail::handler);
++}
++scoped_handler::~scoped_handler()
++{
++ RemoveVectoredExceptionHandler(_handle);
++ jmpbuf = _previous_ptr;
++}
++
++} // detail namespace
++} // sig namespace
++
++#else
++// windows
++
++#include <winnt.h> // for EXCEPTION_*
++
++namespace sig {
++namespace detail {
++
++ // these are the kinds of SEH exceptions we'll translate into C++ exceptions
++ bool catch_error(int const code)
++ {
++ return code == EXCEPTION_IN_PAGE_ERROR
++ || code == EXCEPTION_ACCESS_VIOLATION
++ || code == EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
++ }
++} // detail namespace
++} // namespace sig
++
++#endif // _WIN32
++
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal.hpp
+@@ -0,0 +1,49 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifndef TRY_SIGNAL_HPP_INCLUDED
++#define TRY_SIGNAL_HPP_INCLUDED
++
++#if !defined _WIN32
++// linux
++#include "try_signal_posix.hpp"
++#elif __GNUC__
++// mingw
++#include "try_signal_mingw.hpp"
++#else
++// windows
++#include "try_signal_msvc.hpp"
++#endif
++
++
++#endif // TRY_SIGNAL_HPP_INCLUDED
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_mingw.hpp
+@@ -0,0 +1,78 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifndef TRY_SIGNAL_MINGW_HPP_INCLUDED
++#define TRY_SIGNAL_MINGW_HPP_INCLUDED
++
++#include "signal_error_code.hpp"
++
++#include <setjmp.h> // for jmp_buf
++
++#ifndef WIN32_LEAN_AND_MEAN
++#define WIN32_LEAN_AND_MEAN
++#endif
++#include <windows.h>
++
++namespace sig {
++namespace detail {
++
++struct scoped_handler
++{
++ scoped_handler(jmp_buf* ptr);
++ ~scoped_handler();
++ scoped_handler(scoped_handler const&) = delete;
++ scoped_handler& operator=(scoped_handler const&) = delete;
++private:
++ void* _handle;
++ jmp_buf* _previous_ptr;
++};
++
++} // detail namespace
++
++template <typename Fun>
++void try_signal(Fun&& f)
++{
++ jmp_buf buf;
++ int const code = setjmp(buf);
++ // set the thread local jmpbuf pointer, and make sure it's cleared when we
++ // leave the scope
++ sig::detail::scoped_handler scope(&buf);
++ if (code != 0)
++ throw std::system_error(std::error_code(code, seh_category()));
++
++ f();
++}
++
++} // sig namespace
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_msvc.hpp
+@@ -0,0 +1,61 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifndef TRY_SIGNAL_MSVC_HPP_INCLUDED
++#define TRY_SIGNAL_MSVC_HPP_INCLUDED
++
++#include "signal_error_code.hpp"
++
++namespace sig {
++namespace detail {
++
++bool catch_error(int const code);
++
++} // detail namespace
++
++template <typename Fun>
++void try_signal(Fun&& f)
++{
++ __try
++ {
++ f();
++ }
++ __except (detail::catch_error(GetExceptionCode()))
++ {
++ throw std::system_error(std::error_code(GetExceptionCode(), seh_category()));
++ }
++}
++
++} // sig namespace
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_posix.hpp
+@@ -0,0 +1,82 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifndef TRY_SIGNAL_POSIX_HPP_INCLUDED
++#define TRY_SIGNAL_POSIX_HPP_INCLUDED
++
++#include "signal_error_code.hpp"
++#include <setjmp.h> // for sigjmp_buf
++#include <atomic>
++
++namespace sig {
++
++namespace detail {
++
++extern std::atomic_flag once;
++
++struct scoped_jmpbuf
++{
++ explicit scoped_jmpbuf(sigjmp_buf* ptr);
++ ~scoped_jmpbuf();
++ scoped_jmpbuf(scoped_jmpbuf const&) = delete;
++ scoped_jmpbuf& operator=(scoped_jmpbuf const&) = delete;
++private:
++ sigjmp_buf* _previous_ptr;
++};
++
++void handler(int const signo, siginfo_t* si, void*);
++void setup_handler();
++
++} // detail namespace
++
++template <typename Fun>
++void try_signal(Fun&& f)
++{
++ if (sig::detail::once.test_and_set() == false) {
++ sig::detail::setup_handler();
++ }
++
++ sigjmp_buf buf;
++ int const sig = sigsetjmp(buf, 1);
++ // set the thread local jmpbuf pointer, and make sure it's cleared when we
++ // leave the scope
++ sig::detail::scoped_jmpbuf scope(&buf);
++ if (sig != 0)
++ throw std::system_error(static_cast<sig::errors::error_code_enum>(sig));
++
++ f();
++}
++
++}
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/CMakeLists.txt
+@@ -0,0 +1,61 @@
++project(libsimulator)
++cmake_minimum_required(VERSION 2.8.7)
++
++set(SRC_DIR src)
++set(TEST_SRC_DIR test)
++set(INCLUDE_DIR include)
++set(CMAKE_CXX_STANDARD 14)
++set(CMAKE_CXX_STANDARD_REQUIRED ON)
++
++# Boost.System is header-only (since Boost 1.69), so we only need the Boost
++# headers. Requesting the "system" component fails with recent Boost releases
++# that no longer ship a boost_system CMake config file.
++find_package(Boost REQUIRED)
++find_package(Threads REQUIRED)
++
++set(SIMULATOR_SRC_FILES
++ ${SRC_DIR}/acceptor.cpp
++ ${SRC_DIR}/high_resolution_timer.cpp
++ ${SRC_DIR}/io_service.cpp
++ ${SRC_DIR}/resolver.cpp
++ ${SRC_DIR}/sink_forwarder.cpp
++ ${SRC_DIR}/udp_socket.cpp
++ ${SRC_DIR}/default_config.cpp
++ ${SRC_DIR}/http_proxy.cpp
++ ${SRC_DIR}/pcap.cpp
++ ${SRC_DIR}/simulation.cpp
++ ${SRC_DIR}/socks_server.cpp
++ ${SRC_DIR}/high_resolution_clock.cpp
++ ${SRC_DIR}/http_server.cpp
++ ${SRC_DIR}/queue.cpp
++ ${SRC_DIR}/simulator.cpp
++ ${SRC_DIR}/tcp_socket.cpp
++ ${SRC_DIR}/nat.cpp
++)
++
++add_library(simulator ${SIMULATOR_SRC_FILES})
++target_include_directories(simulator PUBLIC ${INCLUDE_DIR})
++target_link_libraries(simulator PUBLIC Boost::boost)
++
++if(WIN32)
++ target_link_libraries(simulator PRIVATE ws2_32)
++endif()
++
++enable_testing()
++
++function(define_test)
++ set(NAME ${ARGV0})
++ add_executable(${NAME} ${TEST_SRC_DIR}/${NAME}.cpp ${TEST_SRC_DIR}/main.cpp)
++ target_link_libraries(${NAME} simulator)
++ target_link_libraries(${NAME} Threads::Threads)
++ add_test(NAME ${NAME} COMMAND ${NAME})
++endfunction()
++
++define_test(acceptor)
++define_test(multi_accept)
++define_test(multi_homed)
++define_test(null_buffers)
++define_test(parse_request)
++define_test(resolver)
++define_test(timer)
++define_test(udp_socket)
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/Jamfile
+@@ -0,0 +1,136 @@
++# This Jamfile requires boost-build v2 to build.
++
++import path ;
++import modules ;
++import os ;
++import testing ;
++
++BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
++
++ECHO "BOOST_ROOT =" $(BOOST_ROOT) ;
++ECHO "OS =" [ os.name ] ;
++
++lib wsock32 : : <name>wsock32 <link>shared ;
++lib ws2_32 : : <name>ws2_32 <link>shared ;
++
++if $(BOOST_ROOT)
++{
++ use-project /boost : $(BOOST_ROOT) ;
++ alias boost_system : /boost/system//boost_system ;
++}
++else
++{
++ local boost-lib-search-path =
++ <search>/usr/local/opt/boost/lib
++ <search>/opt/homebrew/lib
++ ;
++
++ local boost-include-path =
++ <include>/usr/local/opt/boost/include
++ <include>/opt/homebrew/include
++ ;
++
++ # boost_system is a header-only library now, but we still need to find the boost headers
++ alias boost_system : : : : $(boost-include-path) ;
++}
++
++SOURCES =
++ simulator
++ simulation
++ io_service
++ high_resolution_timer
++ high_resolution_clock
++ tcp_socket
++ udp_socket
++ queue
++ acceptor
++ default_config
++ http_server
++ socks_server
++ resolver
++ http_proxy
++ sink_forwarder
++ pcap
++ nat
++ ;
++
++lib simulator
++ : # sources
++ src/$(SOURCES).cpp
++
++ : # requirements
++ <include>include
++ <library>boost_system
++ <target-os>windows:<library>ws2_32
++ <target-os>windows:<library>wsock32
++ <threading>multi
++
++ <link>shared:<define>SIMULATOR_BUILDING_SHARED
++ <define>_CRT_SECURE_NO_WARNINGS
++
++ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
++ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
++
++ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
++ <define>BOOST_ASIO_HAS_MOVE
++ <define>BOOST_ASIO_ENABLE_CANCELIO
++
++ # make sure asio uses std::chrono
++ <define>BOOST_ASIO_HAS_STD_CHRONO
++
++ # io_executor only implements the legacy (Networking TS v1) executor
++ # concept: this falls any_io_executor back to boost::asio::executor,
++ # which it can wrap, so boost::asio::ssl::stream's bookkeeping timers
++ # work for consumers that include simulator/ssl.hpp.
++ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
++
++ # disable auto-link
++ <define>BOOST_ALL_NO_LIB
++
++ : # default build
++ <warnings>all
++ <warnings-as-errors>on
++ # boost.asio has a global tss_ptr which is the head of a
++ # linked list of all invocations of run on that thread. This
++ # determines whether dispatch() will run the handler immediately
++ # not. The simulator relies on this. On windows each DLL will have
++ # its own copy of this variable, effectively causing a deadlock
++ # in the simulator. So, default to static linking
++ <link>static
++
++ : # usage requirements
++ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
++ <define>BOOST_ASIO_HAS_MOVE
++ <define>BOOST_ASIO_ENABLE_CANCELIO
++ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
++ <threading>multi
++ <include>include
++ <link>shared:<define>SIMULATOR_LINKING_SHARED
++
++ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
++ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
++ ;
++
++project
++ : requirements
++ <library>simulator
++ # disable auto-link
++ <define>BOOST_ALL_NO_LIB
++ : default-build
++ <link>static
++ <threading>multi
++ <cxxstd>14
++ ;
++
++test-suite simulator-tests : [ run
++ test/main.cpp
++ test/resolver.cpp
++ test/multi_homed.cpp
++ test/timer.cpp
++ test/acceptor.cpp
++ test/multi_accept.cpp
++ test/null_buffers.cpp
++ test/udp_socket.cpp
++ test/parse_request.cpp
++ ] ;
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/LICENSE
+@@ -0,0 +1,675 @@
++ GNU GENERAL PUBLIC LICENSE
++ Version 3, 29 June 2007
++
++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
++ Everyone is permitted to copy and distribute verbatim copies
++ of this license document, but changing it is not allowed.
++
++ Preamble
++
++ The GNU General Public License is a free, copyleft license for
++software and other kinds of works.
++
++ The licenses for most software and other practical works are designed
++to take away your freedom to share and change the works. By contrast,
++the GNU General Public License is intended to guarantee your freedom to
++share and change all versions of a program--to make sure it remains free
++software for all its users. We, the Free Software Foundation, use the
++GNU General Public License for most of our software; it applies also to
++any other work released this way by its authors. You can apply it to
++your programs, too.
++
++ When we speak of free software, we are referring to freedom, not
++price. Our General Public Licenses are designed to make sure that you
++have the freedom to distribute copies of free software (and charge for
++them if you wish), that you receive source code or can get it if you
++want it, that you can change the software or use pieces of it in new
++free programs, and that you know you can do these things.
++
++ To protect your rights, we need to prevent others from denying you
++these rights or asking you to surrender the rights. Therefore, you have
++certain responsibilities if you distribute copies of the software, or if
++you modify it: responsibilities to respect the freedom of others.
++
++ For example, if you distribute copies of such a program, whether
++gratis or for a fee, you must pass on to the recipients the same
++freedoms that you received. You must make sure that they, too, receive
++or can get the source code. And you must show them these terms so they
++know their rights.
++
++ Developers that use the GNU GPL protect your rights with two steps:
++(1) assert copyright on the software, and (2) offer you this License
++giving you legal permission to copy, distribute and/or modify it.
++
++ For the developers' and authors' protection, the GPL clearly explains
++that there is no warranty for this free software. For both users' and
++authors' sake, the GPL requires that modified versions be marked as
++changed, so that their problems will not be attributed erroneously to
++authors of previous versions.
++
++ Some devices are designed to deny users access to install or run
++modified versions of the software inside them, although the manufacturer
++can do so. This is fundamentally incompatible with the aim of
++protecting users' freedom to change the software. The systematic
++pattern of such abuse occurs in the area of products for individuals to
++use, which is precisely where it is most unacceptable. Therefore, we
++have designed this version of the GPL to prohibit the practice for those
++products. If such problems arise substantially in other domains, we
++stand ready to extend this provision to those domains in future versions
++of the GPL, as needed to protect the freedom of users.
++
++ Finally, every program is threatened constantly by software patents.
++States should not allow patents to restrict development and use of
++software on general-purpose computers, but in those that do, we wish to
++avoid the special danger that patents applied to a free program could
++make it effectively proprietary. To prevent this, the GPL assures that
++patents cannot be used to render the program non-free.
++
++ The precise terms and conditions for copying, distribution and
++modification follow.
++
++ TERMS AND CONDITIONS
++
++ 0. Definitions.
++
++ "This License" refers to version 3 of the GNU General Public License.
++
++ "Copyright" also means copyright-like laws that apply to other kinds of
++works, such as semiconductor masks.
++
++ "The Program" refers to any copyrightable work licensed under this
++License. Each licensee is addressed as "you". "Licensees" and
++"recipients" may be individuals or organizations.
++
++ To "modify" a work means to copy from or adapt all or part of the work
++in a fashion requiring copyright permission, other than the making of an
++exact copy. The resulting work is called a "modified version" of the
++earlier work or a work "based on" the earlier work.
++
++ A "covered work" means either the unmodified Program or a work based
++on the Program.
++
++ To "propagate" a work means to do anything with it that, without
++permission, would make you directly or secondarily liable for
++infringement under applicable copyright law, except executing it on a
++computer or modifying a private copy. Propagation includes copying,
++distribution (with or without modification), making available to the
++public, and in some countries other activities as well.
++
++ To "convey" a work means any kind of propagation that enables other
++parties to make or receive copies. Mere interaction with a user through
++a computer network, with no transfer of a copy, is not conveying.
++
++ An interactive user interface displays "Appropriate Legal Notices"
++to the extent that it includes a convenient and prominently visible
++feature that (1) displays an appropriate copyright notice, and (2)
++tells the user that there is no warranty for the work (except to the
++extent that warranties are provided), that licensees may convey the
++work under this License, and how to view a copy of this License. If
++the interface presents a list of user commands or options, such as a
++menu, a prominent item in the list meets this criterion.
++
++ 1. Source Code.
++
++ The "source code" for a work means the preferred form of the work
++for making modifications to it. "Object code" means any non-source
++form of a work.
++
++ A "Standard Interface" means an interface that either is an official
++standard defined by a recognized standards body, or, in the case of
++interfaces specified for a particular programming language, one that
++is widely used among developers working in that language.
++
++ The "System Libraries" of an executable work include anything, other
++than the work as a whole, that (a) is included in the normal form of
++packaging a Major Component, but which is not part of that Major
++Component, and (b) serves only to enable use of the work with that
++Major Component, or to implement a Standard Interface for which an
++implementation is available to the public in source code form. A
++"Major Component", in this context, means a major essential component
++(kernel, window system, and so on) of the specific operating system
++(if any) on which the executable work runs, or a compiler used to
++produce the work, or an object code interpreter used to run it.
++
++ The "Corresponding Source" for a work in object code form means all
++the source code needed to generate, install, and (for an executable
++work) run the object code and to modify the work, including scripts to
++control those activities. However, it does not include the work's
++System Libraries, or general-purpose tools or generally available free
++programs which are used unmodified in performing those activities but
++which are not part of the work. For example, Corresponding Source
++includes interface definition files associated with source files for
++the work, and the source code for shared libraries and dynamically
++linked subprograms that the work is specifically designed to require,
++such as by intimate data communication or control flow between those
++subprograms and other parts of the work.
++
++ The Corresponding Source need not include anything that users
++can regenerate automatically from other parts of the Corresponding
++Source.
++
++ The Corresponding Source for a work in source code form is that
++same work.
++
++ 2. Basic Permissions.
++
++ All rights granted under this License are granted for the term of
++copyright on the Program, and are irrevocable provided the stated
++conditions are met. This License explicitly affirms your unlimited
++permission to run the unmodified Program. The output from running a
++covered work is covered by this License only if the output, given its
++content, constitutes a covered work. This License acknowledges your
++rights of fair use or other equivalent, as provided by copyright law.
++
++ You may make, run and propagate covered works that you do not
++convey, without conditions so long as your license otherwise remains
++in force. You may convey covered works to others for the sole purpose
++of having them make modifications exclusively for you, or provide you
++with facilities for running those works, provided that you comply with
++the terms of this License in conveying all material for which you do
++not control copyright. Those thus making or running the covered works
++for you must do so exclusively on your behalf, under your direction
++and control, on terms that prohibit them from making any copies of
++your copyrighted material outside their relationship with you.
++
++ Conveying under any other circumstances is permitted solely under
++the conditions stated below. Sublicensing is not allowed; section 10
++makes it unnecessary.
++
++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
++
++ No covered work shall be deemed part of an effective technological
++measure under any applicable law fulfilling obligations under article
++11 of the WIPO copyright treaty adopted on 20 December 1996, or
++similar laws prohibiting or restricting circumvention of such
++measures.
++
++ When you convey a covered work, you waive any legal power to forbid
++circumvention of technological measures to the extent such circumvention
++is effected by exercising rights under this License with respect to
++the covered work, and you disclaim any intention to limit operation or
++modification of the work as a means of enforcing, against the work's
++users, your or third parties' legal rights to forbid circumvention of
++technological measures.
++
++ 4. Conveying Verbatim Copies.
++
++ You may convey verbatim copies of the Program's source code as you
++receive it, in any medium, provided that you conspicuously and
++appropriately publish on each copy an appropriate copyright notice;
++keep intact all notices stating that this License and any
++non-permissive terms added in accord with section 7 apply to the code;
++keep intact all notices of the absence of any warranty; and give all
++recipients a copy of this License along with the Program.
++
++ You may charge any price or no price for each copy that you convey,
++and you may offer support or warranty protection for a fee.
++
++ 5. Conveying Modified Source Versions.
++
++ You may convey a work based on the Program, or the modifications to
++produce it from the Program, in the form of source code under the
++terms of section 4, provided that you also meet all of these conditions:
++
++ a) The work must carry prominent notices stating that you modified
++ it, and giving a relevant date.
++
++ b) The work must carry prominent notices stating that it is
++ released under this License and any conditions added under section
++ 7. This requirement modifies the requirement in section 4 to
++ "keep intact all notices".
++
++ c) You must license the entire work, as a whole, under this
++ License to anyone who comes into possession of a copy. This
++ License will therefore apply, along with any applicable section 7
++ additional terms, to the whole of the work, and all its parts,
++ regardless of how they are packaged. This License gives no
++ permission to license the work in any other way, but it does not
++ invalidate such permission if you have separately received it.
++
++ d) If the work has interactive user interfaces, each must display
++ Appropriate Legal Notices; however, if the Program has interactive
++ interfaces that do not display Appropriate Legal Notices, your
++ work need not make them do so.
++
++ A compilation of a covered work with other separate and independent
++works, which are not by their nature extensions of the covered work,
++and which are not combined with it such as to form a larger program,
++in or on a volume of a storage or distribution medium, is called an
++"aggregate" if the compilation and its resulting copyright are not
++used to limit the access or legal rights of the compilation's users
++beyond what the individual works permit. Inclusion of a covered work
++in an aggregate does not cause this License to apply to the other
++parts of the aggregate.
++
++ 6. Conveying Non-Source Forms.
++
++ You may convey a covered work in object code form under the terms
++of sections 4 and 5, provided that you also convey the
++machine-readable Corresponding Source under the terms of this License,
++in one of these ways:
++
++ a) Convey the object code in, or embodied in, a physical product
++ (including a physical distribution medium), accompanied by the
++ Corresponding Source fixed on a durable physical medium
++ customarily used for software interchange.
++
++ b) Convey the object code in, or embodied in, a physical product
++ (including a physical distribution medium), accompanied by a
++ written offer, valid for at least three years and valid for as
++ long as you offer spare parts or customer support for that product
++ model, to give anyone who possesses the object code either (1) a
++ copy of the Corresponding Source for all the software in the
++ product that is covered by this License, on a durable physical
++ medium customarily used for software interchange, for a price no
++ more than your reasonable cost of physically performing this
++ conveying of source, or (2) access to copy the
++ Corresponding Source from a network server at no charge.
++
++ c) Convey individual copies of the object code with a copy of the
++ written offer to provide the Corresponding Source. This
++ alternative is allowed only occasionally and noncommercially, and
++ only if you received the object code with such an offer, in accord
++ with subsection 6b.
++
++ d) Convey the object code by offering access from a designated
++ place (gratis or for a charge), and offer equivalent access to the
++ Corresponding Source in the same way through the same place at no
++ further charge. You need not require recipients to copy the
++ Corresponding Source along with the object code. If the place to
++ copy the object code is a network server, the Corresponding Source
++ may be on a different server (operated by you or a third party)
++ that supports equivalent copying facilities, provided you maintain
++ clear directions next to the object code saying where to find the
++ Corresponding Source. Regardless of what server hosts the
++ Corresponding Source, you remain obligated to ensure that it is
++ available for as long as needed to satisfy these requirements.
++
++ e) Convey the object code using peer-to-peer transmission, provided
++ you inform other peers where the object code and Corresponding
++ Source of the work are being offered to the general public at no
++ charge under subsection 6d.
++
++ A separable portion of the object code, whose source code is excluded
++from the Corresponding Source as a System Library, need not be
++included in conveying the object code work.
++
++ A "User Product" is either (1) a "consumer product", which means any
++tangible personal property which is normally used for personal, family,
++or household purposes, or (2) anything designed or sold for incorporation
++into a dwelling. In determining whether a product is a consumer product,
++doubtful cases shall be resolved in favor of coverage. For a particular
++product received by a particular user, "normally used" refers to a
++typical or common use of that class of product, regardless of the status
++of the particular user or of the way in which the particular user
++actually uses, or expects or is expected to use, the product. A product
++is a consumer product regardless of whether the product has substantial
++commercial, industrial or non-consumer uses, unless such uses represent
++the only significant mode of use of the product.
++
++ "Installation Information" for a User Product means any methods,
++procedures, authorization keys, or other information required to install
++and execute modified versions of a covered work in that User Product from
++a modified version of its Corresponding Source. The information must
++suffice to ensure that the continued functioning of the modified object
++code is in no case prevented or interfered with solely because
++modification has been made.
++
++ If you convey an object code work under this section in, or with, or
++specifically for use in, a User Product, and the conveying occurs as
++part of a transaction in which the right of possession and use of the
++User Product is transferred to the recipient in perpetuity or for a
++fixed term (regardless of how the transaction is characterized), the
++Corresponding Source conveyed under this section must be accompanied
++by the Installation Information. But this requirement does not apply
++if neither you nor any third party retains the ability to install
++modified object code on the User Product (for example, the work has
++been installed in ROM).
++
++ The requirement to provide Installation Information does not include a
++requirement to continue to provide support service, warranty, or updates
++for a work that has been modified or installed by the recipient, or for
++the User Product in which it has been modified or installed. Access to a
++network may be denied when the modification itself materially and
++adversely affects the operation of the network or violates the rules and
++protocols for communication across the network.
++
++ Corresponding Source conveyed, and Installation Information provided,
++in accord with this section must be in a format that is publicly
++documented (and with an implementation available to the public in
++source code form), and must require no special password or key for
++unpacking, reading or copying.
++
++ 7. Additional Terms.
++
++ "Additional permissions" are terms that supplement the terms of this
++License by making exceptions from one or more of its conditions.
++Additional permissions that are applicable to the entire Program shall
++be treated as though they were included in this License, to the extent
++that they are valid under applicable law. If additional permissions
++apply only to part of the Program, that part may be used separately
++under those permissions, but the entire Program remains governed by
++this License without regard to the additional permissions.
++
++ When you convey a copy of a covered work, you may at your option
++remove any additional permissions from that copy, or from any part of
++it. (Additional permissions may be written to require their own
++removal in certain cases when you modify the work.) You may place
++additional permissions on material, added by you to a covered work,
++for which you have or can give appropriate copyright permission.
++
++ Notwithstanding any other provision of this License, for material you
++add to a covered work, you may (if authorized by the copyright holders of
++that material) supplement the terms of this License with terms:
++
++ a) Disclaiming warranty or limiting liability differently from the
++ terms of sections 15 and 16 of this License; or
++
++ b) Requiring preservation of specified reasonable legal notices or
++ author attributions in that material or in the Appropriate Legal
++ Notices displayed by works containing it; or
++
++ c) Prohibiting misrepresentation of the origin of that material, or
++ requiring that modified versions of such material be marked in
++ reasonable ways as different from the original version; or
++
++ d) Limiting the use for publicity purposes of names of licensors or
++ authors of the material; or
++
++ e) Declining to grant rights under trademark law for use of some
++ trade names, trademarks, or service marks; or
++
++ f) Requiring indemnification of licensors and authors of that
++ material by anyone who conveys the material (or modified versions of
++ it) with contractual assumptions of liability to the recipient, for
++ any liability that these contractual assumptions directly impose on
++ those licensors and authors.
++
++ All other non-permissive additional terms are considered "further
++restrictions" within the meaning of section 10. If the Program as you
++received it, or any part of it, contains a notice stating that it is
++governed by this License along with a term that is a further
++restriction, you may remove that term. If a license document contains
++a further restriction but permits relicensing or conveying under this
++License, you may add to a covered work material governed by the terms
++of that license document, provided that the further restriction does
++not survive such relicensing or conveying.
++
++ If you add terms to a covered work in accord with this section, you
++must place, in the relevant source files, a statement of the
++additional terms that apply to those files, or a notice indicating
++where to find the applicable terms.
++
++ Additional terms, permissive or non-permissive, may be stated in the
++form of a separately written license, or stated as exceptions;
++the above requirements apply either way.
++
++ 8. Termination.
++
++ You may not propagate or modify a covered work except as expressly
++provided under this License. Any attempt otherwise to propagate or
++modify it is void, and will automatically terminate your rights under
++this License (including any patent licenses granted under the third
++paragraph of section 11).
++
++ However, if you cease all violation of this License, then your
++license from a particular copyright holder is reinstated (a)
++provisionally, unless and until the copyright holder explicitly and
++finally terminates your license, and (b) permanently, if the copyright
++holder fails to notify you of the violation by some reasonable means
++prior to 60 days after the cessation.
++
++ Moreover, your license from a particular copyright holder is
++reinstated permanently if the copyright holder notifies you of the
++violation by some reasonable means, this is the first time you have
++received notice of violation of this License (for any work) from that
++copyright holder, and you cure the violation prior to 30 days after
++your receipt of the notice.
++
++ Termination of your rights under this section does not terminate the
++licenses of parties who have received copies or rights from you under
++this License. If your rights have been terminated and not permanently
++reinstated, you do not qualify to receive new licenses for the same
++material under section 10.
++
++ 9. Acceptance Not Required for Having Copies.
++
++ You are not required to accept this License in order to receive or
++run a copy of the Program. Ancillary propagation of a covered work
++occurring solely as a consequence of using peer-to-peer transmission
++to receive a copy likewise does not require acceptance. However,
++nothing other than this License grants you permission to propagate or
++modify any covered work. These actions infringe copyright if you do
++not accept this License. Therefore, by modifying or propagating a
++covered work, you indicate your acceptance of this License to do so.
++
++ 10. Automatic Licensing of Downstream Recipients.
++
++ Each time you convey a covered work, the recipient automatically
++receives a license from the original licensors, to run, modify and
++propagate that work, subject to this License. You are not responsible
++for enforcing compliance by third parties with this License.
++
++ An "entity transaction" is a transaction transferring control of an
++organization, or substantially all assets of one, or subdividing an
++organization, or merging organizations. If propagation of a covered
++work results from an entity transaction, each party to that
++transaction who receives a copy of the work also receives whatever
++licenses to the work the party's predecessor in interest had or could
++give under the previous paragraph, plus a right to possession of the
++Corresponding Source of the work from the predecessor in interest, if
++the predecessor has it or can get it with reasonable efforts.
++
++ You may not impose any further restrictions on the exercise of the
++rights granted or affirmed under this License. For example, you may
++not impose a license fee, royalty, or other charge for exercise of
++rights granted under this License, and you may not initiate litigation
++(including a cross-claim or counterclaim in a lawsuit) alleging that
++any patent claim is infringed by making, using, selling, offering for
++sale, or importing the Program or any portion of it.
++
++ 11. Patents.
++
++ A "contributor" is a copyright holder who authorizes use under this
++License of the Program or a work on which the Program is based. The
++work thus licensed is called the contributor's "contributor version".
++
++ A contributor's "essential patent claims" are all patent claims
++owned or controlled by the contributor, whether already acquired or
++hereafter acquired, that would be infringed by some manner, permitted
++by this License, of making, using, or selling its contributor version,
++but do not include claims that would be infringed only as a
++consequence of further modification of the contributor version. For
++purposes of this definition, "control" includes the right to grant
++patent sublicenses in a manner consistent with the requirements of
++this License.
++
++ Each contributor grants you a non-exclusive, worldwide, royalty-free
++patent license under the contributor's essential patent claims, to
++make, use, sell, offer for sale, import and otherwise run, modify and
++propagate the contents of its contributor version.
++
++ In the following three paragraphs, a "patent license" is any express
++agreement or commitment, however denominated, not to enforce a patent
++(such as an express permission to practice a patent or covenant not to
++sue for patent infringement). To "grant" such a patent license to a
++party means to make such an agreement or commitment not to enforce a
++patent against the party.
++
++ If you convey a covered work, knowingly relying on a patent license,
++and the Corresponding Source of the work is not available for anyone
++to copy, free of charge and under the terms of this License, through a
++publicly available network server or other readily accessible means,
++then you must either (1) cause the Corresponding Source to be so
++available, or (2) arrange to deprive yourself of the benefit of the
++patent license for this particular work, or (3) arrange, in a manner
++consistent with the requirements of this License, to extend the patent
++license to downstream recipients. "Knowingly relying" means you have
++actual knowledge that, but for the patent license, your conveying the
++covered work in a country, or your recipient's use of the covered work
++in a country, would infringe one or more identifiable patents in that
++country that you have reason to believe are valid.
++
++ If, pursuant to or in connection with a single transaction or
++arrangement, you convey, or propagate by procuring conveyance of, a
++covered work, and grant a patent license to some of the parties
++receiving the covered work authorizing them to use, propagate, modify
++or convey a specific copy of the covered work, then the patent license
++you grant is automatically extended to all recipients of the covered
++work and works based on it.
++
++ A patent license is "discriminatory" if it does not include within
++the scope of its coverage, prohibits the exercise of, or is
++conditioned on the non-exercise of one or more of the rights that are
++specifically granted under this License. You may not convey a covered
++work if you are a party to an arrangement with a third party that is
++in the business of distributing software, under which you make payment
++to the third party based on the extent of your activity of conveying
++the work, and under which the third party grants, to any of the
++parties who would receive the covered work from you, a discriminatory
++patent license (a) in connection with copies of the covered work
++conveyed by you (or copies made from those copies), or (b) primarily
++for and in connection with specific products or compilations that
++contain the covered work, unless you entered into that arrangement,
++or that patent license was granted, prior to 28 March 2007.
++
++ Nothing in this License shall be construed as excluding or limiting
++any implied license or other defenses to infringement that may
++otherwise be available to you under applicable patent law.
++
++ 12. No Surrender of Others' Freedom.
++
++ If conditions are imposed on you (whether by court order, agreement or
++otherwise) that contradict the conditions of this License, they do not
++excuse you from the conditions of this License. If you cannot convey a
++covered work so as to satisfy simultaneously your obligations under this
++License and any other pertinent obligations, then as a consequence you may
++not convey it at all. For example, if you agree to terms that obligate you
++to collect a royalty for further conveying from those to whom you convey
++the Program, the only way you could satisfy both those terms and this
++License would be to refrain entirely from conveying the Program.
++
++ 13. Use with the GNU Affero General Public License.
++
++ Notwithstanding any other provision of this License, you have
++permission to link or combine any covered work with a work licensed
++under version 3 of the GNU Affero General Public License into a single
++combined work, and to convey the resulting work. The terms of this
++License will continue to apply to the part which is the covered work,
++but the special requirements of the GNU Affero General Public License,
++section 13, concerning interaction through a network will apply to the
++combination as such.
++
++ 14. Revised Versions of this License.
++
++ The Free Software Foundation may publish revised and/or new versions of
++the GNU General Public License from time to time. Such new versions will
++be similar in spirit to the present version, but may differ in detail to
++address new problems or concerns.
++
++ Each version is given a distinguishing version number. If the
++Program specifies that a certain numbered version of the GNU General
++Public License "or any later version" applies to it, you have the
++option of following the terms and conditions either of that numbered
++version or of any later version published by the Free Software
++Foundation. If the Program does not specify a version number of the
++GNU General Public License, you may choose any version ever published
++by the Free Software Foundation.
++
++ If the Program specifies that a proxy can decide which future
++versions of the GNU General Public License can be used, that proxy's
++public statement of acceptance of a version permanently authorizes you
++to choose that version for the Program.
++
++ Later license versions may give you additional or different
++permissions. However, no additional obligations are imposed on any
++author or copyright holder as a result of your choosing to follow a
++later version.
++
++ 15. Disclaimer of Warranty.
++
++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
++APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
++HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
++OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
++THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
++IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
++ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
++
++ 16. Limitation of Liability.
++
++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
++THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
++GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
++USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
++DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
++PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
++EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
++SUCH DAMAGES.
++
++ 17. Interpretation of Sections 15 and 16.
++
++ If the disclaimer of warranty and limitation of liability provided
++above cannot be given local legal effect according to their terms,
++reviewing courts shall apply local law that most closely approximates
++an absolute waiver of all civil liability in connection with the
++Program, unless a warranty or assumption of liability accompanies a
++copy of the Program in return for a fee.
++
++ END OF TERMS AND CONDITIONS
++
++ How to Apply These Terms to Your New Programs
++
++ If you develop a new program, and you want it to be of the greatest
++possible use to the public, the best way to achieve this is to make it
++free software which everyone can redistribute and change under these terms.
++
++ To do so, attach the following notices to the program. It is safest
++to attach them to the start of each source file to most effectively
++state the exclusion of warranty; and each file should have at least
++the "copyright" line and a pointer to where the full notice is found.
++
++ {one line to give the program's name and a brief idea of what it does.}
++ Copyright (C) {year} {name of author}
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++Also add information on how to contact you by electronic and paper mail.
++
++ If the program does terminal interaction, make it output a short
++notice like this when it starts in an interactive mode:
++
++ {project} Copyright (C) {year} {fullname}
++ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
++ This is free software, and you are welcome to redistribute it
++ under certain conditions; type `show c' for details.
++
++The hypothetical commands `show w' and `show c' should show the appropriate
++parts of the General Public License. Of course, your program's commands
++might be different; for a GUI interface, you would use an "about box".
++
++ You should also get your employer (if you work as a programmer) or school,
++if any, to sign a "copyright disclaimer" for the program, if necessary.
++For more information on this, and how to apply and follow the GNU GPL, see
++<http://www.gnu.org/licenses/>.
++
++ The GNU General Public License does not permit incorporating your program
++into proprietary programs. If your program is a subroutine library, you
++may consider it more useful to permit linking proprietary applications with
++the library. If this is what you want to do, use the GNU Lesser General
++Public License instead of this License. But first, please read
++<http://www.gnu.org/philosophy/why-not-lgpl.html>.
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/README.rst
+@@ -0,0 +1,199 @@
++libsimulator
++============
++
++.. image:: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml/badge.svg?branch=master
++ :target: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml
++
++*This is still in initial development, some of this README represents ambitions
++rather than the current state*
++
++libsimulator is a library for running discrete event simulations, implementing
++the ``boost.asio`` API (or a somewhat faithful emulation of a subset of it,
++patches are welcome). This makes it practical to be used as a testing tool of
++real implementations of network software as well as for writing simulators that
++later turn into live production applications.
++
++The simulation has to have a single time-line to be deterministic, meaning it
++must be single threaded and use a single ``io_service`` as the message queue.
++These requirements may affect how the program to be tested is written. It may
++for instance require that an external io_service can be provided rather than one
++being wrapped in an internal thread.
++
++However, ``boost.asio`` programs may generally benefit from being transformed to
++this form, as the become *composable*, i.e. agnostic to which io_service they
++run on or how many threads are running it.
++
++features
++--------
++
++The currently (partially) supported classes are:
++
++* chrono::high_resolution_clock
++* asio::high_resolution_timer
++* asio::ip::tcp::acceptor
++* asio::ip::tcp::endpoint
++* asio::ip::address (v4 and v6 variants, these just defer to the actual
++ boost.asio types)
++* asio::ip::tcp::socket
++* asio::ip::udp::socket
++* asio::io_service
++* asio::ip::udp::resolver
++* asio::ip::tcp::resolver
++
++The ``high_resolution_clock`` in the ``chrono`` namespace implements the timer
++concept from the chrono library.
++
++usage
++-----
++
++The ``io_service`` object is significantly different from the one in boost.asio.
++This is because one simulation may only have a single message loop and a single
++ordering of events. This single message loop is provided by the ``simulation``
++class. Each simulation should have only one such object. An ``io_service``
++object represents a single node on the network. When creating an io_service, you
++have to pass in the simulation it belongs to as well as the IP address it should
++have. It is also possible to pass in multiple addresses to form a multi-homed
++node. For instance, one with both an IPv4 and IPv6 interface.
++
++When creating sockets, binding and connecting them, the io_service object
++determines what ``INADDR_ANY`` resolves to (the first IP assigned to that node).
++
++The only aspects of the io_service interface that's preserved are ``post()``,
++``dispatch()`` and constructing timers and sockets. In short, the ``run()`` and
++``poll()`` family of functions do not exist. Every io_service object is assumed
++to be run, and all of their events are handled by the simulation object.
++
++None of the synchronous APIs are supported, because that would require
++integration with OS threads and scheduler.
++
++example
++-------
++
++Here's a simple example illustrating the asio timer::
++
++ #include "simulator/simulator.hpp"
++ #include <functional>
++ #include <boost/system.hpp>
++
++ void print_time(sim::asio::high_resolution_timer& timer
++ , boost::system::error_code const& ec)
++ {
++ using namespace sim::chrono;
++ static int counter = 0;
++
++ printf("[%d] timer fired at: %d milliseconds. error: %s\n"
++ , counter
++ , int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count())
++ , ec.message().c_str());
++
++ ++counter;
++ if (counter < 5)
++ {
++ timer.expires_from_now(seconds(counter));
++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
++ }
++ }
++
++ int main()
++ {
++ using namespace sim::chrono;
++
++ default_config cfg;
++ simulation sim(cfg);
++ io_service ios(sim, ip::address_v4::from_string("1.2.3.4"));
++ sim::asio::high_resolution_timer timer(ios);
++
++ timer.expires_from_now(seconds(1));
++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
++
++ boost::system::error_code ec;
++ sim.run(ec);
++
++ printf("sim::run() returned: %s at: %d\n"
++ , ec.message().c_str()
++ , int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count()));
++ }
++
++The output from this program is::
++
++ [0] timer fired at: 1000 milliseconds. error: Undefined error: 0
++ [1] timer fired at: 2000 milliseconds. error: Undefined error: 0
++ [2] timer fired at: 4000 milliseconds. error: Undefined error: 0
++ [3] timer fired at: 7000 milliseconds. error: Undefined error: 0
++ [4] timer fired at: 11000 milliseconds. error: Undefined error: 0
++ io_service::run() returned: Undefined error: 0 at: 11000
++
++And obviously it doesn't take 11 wall-clock seconds to run (it returns
++instantly).
++
++configuration
++-------------
++
++The simulated network can be configured with per-node pair bandwidth, round-trip
++latency and queue sizes. This is controlled via a callback interface that
++libsimulator will ask for these properties when nodes get connected.
++
++The resolution of hostnames is also configurable by providing a callback on the
++configuration object along with the latency of individual lookups.
++
++To configure the network for the simulation, pass in a reference to an object
++implementing the ``sim::configuration`` interface::
++
++ struct configuration
++ {
++ // build the network
++ virtual void build(simulation& sim) = 0;
++
++ // return the hops on the network packets from src to dst need to traverse
++ virtual route channel_route(asio::ip::address src
++ , asio::ip::address dst) = 0;
++
++ // return the hops an incoming packet to ep need to traverse before
++ // reaching the socket (for instance a NAT)
++ virtual route incoming_route(asio::ip::address ip) = 0;
++
++ // return the hops an outgoing packet from ep need to traverse before
++ // reaching the network (for instance a DSL modem)
++ virtual route outgoing_route(asio::ip::address ip) = 0;
++
++ // return the path MTU between the two IP addresses
++ // For TCP sockets, this will be called once when the connection is
++ // established. For UDP sockets it's called for every burst of packets
++ // that are sent
++ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
++
++ // called for every hostname lookup made by the client. ``reqyestor`` is
++ // the node performing the lookup, ``hostname`` is the name being looked
++ // up. Resolve the name into addresses and fill in ``result`` or set
++ // ``ec`` if the hostname is not found or some other error occurs. The
++ // return value is the latency of the lookup. The client's callback won't
++ // be called until after waiting this long.
++ virtual chrono::high_resolution_clock::duration hostname_lookup(
++ asio::ip::address const& requestor
++ , std::string hostname
++ , std::vector<asio::ip::address>& result
++ , boost::system::error_code& ec) = 0;
++ };
++
++``build()`` is called right after the simulation is constructed. It gives the
++configuration object an opportunity to construct the core queues, since they
++need access to the simulator.
++
++``channel_route()`` is expected to return a *route* of network hops from the
++source IP to the destination IP. A route is a series of ``sink`` objects. The
++typical sink is a ``sim::queue``, which is a network node with a specific rate
++limit, propagation delay and queue size.
++
++*TODO: finish document configuration interface*
++
++history
++-------
++
++libsimulator grew out of libtorrent's unit tests, as a tool to make them reliable
++and deterministic (i.e. not depend on external systems like sockets and timers)
++and also easier to debug. The subset of the asio API initially supported by this
++library is the subset used by libtorrent. Patches are welcome to improve
++fidelity and support.
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/chrono.hpp
+@@ -0,0 +1,87 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef CHRONO_HPP_INCLUDED
++#define CHRONO_HPP_INCLUDED
++
++#include <boost/config.hpp>
++#include "simulator/config.hpp"
++
++#if defined BOOST_ASIO_HAS_STD_CHRONO
++#include <chrono>
++#else
++#include "simulator/push_warnings.hpp"
++
++#include <boost/chrono/duration.hpp>
++#include <boost/chrono/time_point.hpp>
++#include <boost/ratio.hpp>
++
++#include "simulator/pop_warnings.hpp"
++#endif
++
++namespace sim { namespace chrono
++{
++#if defined BOOST_ASIO_HAS_STD_CHRONO
++ using std::chrono::seconds;
++ using std::chrono::milliseconds;
++ using std::chrono::microseconds;
++ using std::chrono::nanoseconds;
++ using std::chrono::minutes;
++ using std::chrono::hours;
++ using std::chrono::duration_cast;
++ using std::chrono::time_point;
++ using std::chrono::duration;
++#else
++ using boost::chrono::seconds;
++ using boost::chrono::milliseconds;
++ using boost::chrono::microseconds;
++ using boost::chrono::nanoseconds;
++ using boost::chrono::minutes;
++ using boost::chrono::hours;
++ using boost::chrono::duration_cast;
++ using boost::chrono::time_point;
++ using boost::chrono::duration;
++#endif
++
++ // std.chrono / boost.chrono compatible high_resolution_clock using a simulated time
++ struct SIMULATOR_DECL high_resolution_clock
++ {
++ using rep = std::int64_t;
++#if defined BOOST_ASIO_HAS_STD_CHRONO
++ using period = std::nano;
++ using time_point = std::chrono::time_point<high_resolution_clock, nanoseconds>;
++ using duration = std::chrono::duration<boost::int64_t, std::nano>;
++#else
++ using period = boost::nano;
++ using time_point = time_point<high_resolution_clock, nanoseconds>;
++ using duration = duration<boost::int64_t, boost::nano>;
++#endif
++ static const bool is_steady = true;
++ static time_point now();
++
++ // private interface
++ static void fast_forward(high_resolution_clock::duration d);
++ };
++
++ SIMULATOR_DECL void reset_clock();
++
++} // chrono
++} // sim
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/config.hpp
+@@ -0,0 +1,51 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef CONFIG_HPP_INCLUDED
++#define CONFIG_HPP_INCLUDED
++
++#include "simulator/push_warnings.hpp"
++#include <boost/config.hpp>
++#include "simulator/pop_warnings.hpp"
++
++#ifdef SIMULATOR_BUILDING_SHARED
++#define SIMULATOR_DECL BOOST_SYMBOL_EXPORT
++#elif defined SIMULATOR_LINKING_SHARED
++#define SIMULATOR_DECL BOOST_SYMBOL_IMPORT
++#else
++#define SIMULATOR_DECL
++#endif
++
++#if defined __clang__ || defined __GNUC__
++#define LIBSIMULATOR_NO_RETURN __attribute((noreturn))
++#elif _MSC_VER
++#define LIBSIMULATOR_NO_RETURN __declspec(noreturn)
++#else
++#define LIBSIMULATOR_NO_RETURN
++#endif
++
++#ifdef _MSC_VER
++#pragma warning(push)
++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
++#pragma warning( disable : 4251)
++// warning C4661: X: no suitable definition provided for explicit template instantiation request
++#pragma warning( disable : 4661)
++#endif
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/function.hpp
+@@ -0,0 +1,220 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SIMULATOR_FUNCTION_HPP_INCLUDED
++#define SIMULATOR_FUNCTION_HPP_INCLUDED
++
++#include <utility>
++#include <memory> // for allocator_traits
++
++#include "simulator/mallocator.hpp"
++
++namespace sim {
++namespace aux {
++
++ template <typename T, typename U>
++ T exchange_(T& var, U&& new_val)
++ {
++ T temp = std::move(var);
++ var = std::forward<U>(new_val);
++ return temp;
++ }
++
++ template <typename T, typename Fun>
++ T* allocate_handler(Fun h)
++ {
++ using alloc = typename boost::asio::associated_allocator<typename std::remove_reference<Fun>::type>::type;
++ using our_alloc = typename std::allocator_traits<alloc>::template rebind_alloc<T>;
++ our_alloc al(boost::asio::get_associated_allocator(h));
++ void* ptr = al.allocate(1);
++ if (ptr == nullptr) throw std::bad_alloc();
++ try {
++ return new (ptr) T(std::move(h));
++ }
++ catch (...) {
++ al.deallocate(reinterpret_cast<T*>(ptr), 1);
++ throw;
++ }
++ }
++
++ // this is a std::function-like class that supports move-only function
++ // objects
++ template <typename R, typename... A>
++ struct callable
++ {
++ using call_fun_t = R (*)(void*, A&&...);
++ using deallocate_fun_t = void (*)(void*);
++ call_fun_t call_fun;
++ deallocate_fun_t deallocate_fun;
++ };
++
++ template <typename Handler, typename R, typename... A>
++ R call_impl(void* mem, A&&... a);
++
++ template <typename Handler, typename R, typename... A>
++ void dealloc_impl(void* mem);
++
++ template <typename Handler, typename R, typename... A>
++ struct function_impl : callable<R, A...>
++ {
++ function_impl(Handler h)
++ : handler(std::move(h))
++ {
++ this->call_fun = call_impl<Handler, R, A&&...>;
++ this->deallocate_fun = dealloc_impl<Handler, R, A&&...>;
++ }
++ Handler handler;
++ };
++
++ template <typename Handler, typename R, typename... A>
++ R call_impl(void* mem, A&&... a)
++ {
++ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
++ Handler handler = std::move(obj->handler);
++
++ obj->~function_impl();
++ using alloc = typename boost::asio::associated_allocator<Handler>::type;
++ using our_alloc = typename std::allocator_traits<alloc>::
++ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
++ our_alloc al(boost::asio::get_associated_allocator(handler));
++ al.deallocate(obj, 1);
++
++ return handler(std::forward<A>(a)...);
++ }
++
++ template <typename Handler, typename R, typename... A>
++ void dealloc_impl(void* mem)
++ {
++ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
++ Handler h = std::move(obj->handler);
++
++ obj->~function_impl();
++ using alloc = typename boost::asio::associated_allocator<Handler>::type;
++ using our_alloc = typename std::allocator_traits<alloc>::
++ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
++ our_alloc al(boost::asio::get_associated_allocator(h));
++ al.deallocate(obj, 1);
++ }
++
++ template <typename Fun>
++ struct function;
++
++ template <typename R, typename... A>
++ struct function<R(A...)>
++ {
++ using result_type = R;
++
++ using allocator_type = aux::mallocator<R(A...)>;
++ allocator_type get_allocator() const { return allocator_type{}; }
++
++ template <typename C>
++ function(C c)
++ : m_callable(allocate_handler<function_impl<C, R, A...>>(std::move(c)))
++ {}
++ function(function&& other) noexcept
++ : m_callable(exchange_(other.m_callable, nullptr))
++ {}
++ function& operator=(function&& other) noexcept
++ {
++ if (&other == this) return *this;
++ clear();
++ m_callable = exchange_(other.m_callable, nullptr);
++ return *this;
++ }
++
++ ~function() { clear(); }
++
++ // boost.asio requires handlers to be copy-constructible, but it will move
++ // them, if they're movable. So we trick asio into accepting this handler.
++ // If it attempts to copy, it will cause a link error
++ function(function const&) { assert(false && "functions should not be copied"); }
++ function& operator=(function const&) = delete;
++
++ function() = default;
++ explicit operator bool() const { return m_callable != nullptr; }
++ function& operator=(std::nullptr_t) { clear(); return *this; }
++ void clear()
++ {
++ if (m_callable == nullptr) return;
++ auto fun = m_callable->deallocate_fun;
++ fun(m_callable);
++ m_callable = nullptr;
++ }
++ template <typename... Args>
++ R operator()(Args&&... a)
++ {
++ assert(m_callable);
++ auto fun = m_callable->call_fun;
++ return fun(exchange_(m_callable, nullptr), std::forward<A>(a)...);
++ }
++ private:
++ callable<R, A...>* m_callable = nullptr;
++ };
++
++ // index sequence, to unpack tuple
++ template<std::size_t...> struct seq {};
++ template<std::size_t N, std::size_t... S> struct gens : gens<N-1, N-1, S...> {};
++ template<std::size_t... S> struct gens<0, S...> { using type = seq<S...>; };
++
++ // a binder for move-only types, and movable arguments. It's not a general
++ // binder as it doesn't support partial application, it just binds all
++ // arguments and ignores any arguments passed to the call
++ template <typename Callable, typename R, typename... A>
++ struct move_binder
++ {
++ move_binder(Callable c, A&&... a)
++ : m_args(std::move(a)...)
++ , m_callable(std::move(c))
++ {}
++
++ move_binder(move_binder const&) = delete;
++ move_binder& operator=(move_binder const&) = delete;
++
++ move_binder(move_binder&&) = default;
++ move_binder& operator=(move_binder&&) = default;
++
++ // ignore any arguments passed in. This is used to ignore an error_code
++ // argument for instance
++ template <typename... Args>
++ R operator()(Args...)
++ {
++ return call(typename gens<sizeof...(A)>::type());
++ }
++
++ private:
++
++ template<std::size_t... I>
++ R call(seq<I...>)
++ {
++ return m_callable(std::move(std::get<I>(m_args))...);
++ }
++ std::tuple<A...> m_args;
++ Callable m_callable;
++ };
++
++ template <typename R, typename C, typename... A>
++ move_binder<C, R, A...> move_bind(C c, A&&... a)
++ {
++ return move_binder<C, R, A...>(std::move(c), std::forward<A>(a)...);
++ }
++
++}
++}
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/handler_allocator.hpp
+@@ -0,0 +1,81 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef HANDLER_ALLOCATOR_HPP_INCLUDED
++#define HANDLER_ALLOCATOR_HPP_INCLUDED
++
++namespace sim
++{
++namespace aux
++{
++
++template <typename T>
++struct malloc_allocator
++{
++ using value_type = T;
++ using size_type = std::size_t;
++
++ friend bool operator==(malloc_allocator, malloc_allocator) { return true; }
++ friend bool operator!=(malloc_allocator, malloc_allocator) { return false; }
++
++ template <class U>
++ struct rebind { using other = malloc_allocator<U>; };
++
++ malloc_allocator() = default;
++ template <typename U>
++ malloc_allocator(malloc_allocator<U> const&) {}
++
++ T* allocate(std::size_t size) { return static_cast<T*>(std::malloc(size * sizeof(T))); }
++ void deallocate(T* pointer, std::size_t) { std::free(pointer); }
++ using is_always_equal = std::true_type;
++};
++
++// this is a handler wrapper that customizes the asio handler allocator to use
++// malloc instead of new. The purpose is to distinguish allocations that are
++// internal to the simulator and allocations part of the program under test.
++template <typename Handler>
++struct malloc_wrapper
++{
++ malloc_wrapper(Handler h) : m_handler(std::move(h)) {}
++
++ template <typename... Args>
++ void operator()(Args&&... a)
++ {
++ m_handler(std::forward<Args>(a)...);
++ }
++
++ using allocator_type = malloc_allocator<malloc_wrapper<Handler>>;
++
++ allocator_type get_allocator() const noexcept
++ { return allocator_type{}; }
++
++private:
++ Handler m_handler;
++};
++
++template <typename T>
++malloc_wrapper<T> make_malloc(T h)
++{
++ return malloc_wrapper<T>(std::move(h));
++}
++
++}
++}
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/http_proxy.hpp
+@@ -0,0 +1,103 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef HTTP_PROXY_HPP_INCLUDED
++#define HTTP_PROXY_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++
++#ifdef _MSC_VER
++#pragma warning(push)
++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
++#pragma warning( disable : 4251)
++#endif
++
++namespace sim
++{
++ struct http_request;
++
++// This is a very simple http proxy that only supports a single
++// concurrent connection
++struct SIMULATOR_DECL http_proxy
++{
++ http_proxy(asio::io_context& ios, unsigned short listen_port);
++
++ void stop();
++
++private:
++
++ void on_accept(boost::system::error_code const& ec);
++ void on_read_request(boost::system::error_code const& ec, size_t bytes_transferred);
++
++ void forward_request(http_request const& req);
++ void open_forward_connection(const asio::ip::tcp::endpoint& target);
++ void on_connected(boost::system::error_code const& ec);
++
++ void on_domain_lookup(boost::system::error_code const& ec
++ , const asio::ip::tcp::resolver::results_type ips);
++
++ void write_server_send_buffer();
++ void on_server_write(boost::system::error_code const& ec, size_t bytes_transferred);
++
++ void on_server_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred);
++ void on_server_forward(boost::system::error_code const& ec, size_t bytes_transferred);
++
++ void error(int code, char const* message);
++ void close_connection();
++
++ asio::ip::tcp::resolver m_resolver;
++ asio::ip::tcp::acceptor m_listen_socket;
++
++ // this is the client connection, i.e. the client connecting to us, sending
++ // HTTP requests that we forward
++ asio::ip::tcp::socket m_client_connection;
++ // client endpoint
++ asio::ip::tcp::endpoint m_ep;
++
++ // this is the connection to the server the client's requests are forwarded
++ // to
++ asio::ip::tcp::socket m_server_connection;
++ // true while there is an outstanding write operation to the server
++ bool m_writing_to_server;
++
++ // receive buffer for requests from the client. i.e. client -> proxy (us) -> server
++ char m_client_in_buffer[65536];
++ // buffer size
++ int m_num_client_in_bytes;
++
++ char m_server_out_buffer[65536];
++ int m_num_server_out_bytes;
++
++ // receive buffer for incoming responses, i.e. server -> proxy (us) -> client
++ char m_in_buffer[65536];
++ // buffer size
++ int m_num_in_bytes;
++
++ // set to true when shutting down
++ bool m_close;
++};
++
++}
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/http_server.hpp
+@@ -0,0 +1,134 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef HTTP_SERVER_HPP_INCLUDED
++#define HTTP_SERVER_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++#include <string>
++
++#ifdef _MSC_VER
++#pragma warning(push)
++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
++#pragma warning( disable : 4251)
++#endif
++
++namespace sim
++{
++ std::string SIMULATOR_DECL trim(std::string s);
++
++ std::string SIMULATOR_DECL lower_case(std::string s);
++
++ std::string SIMULATOR_DECL normalize(const std::string& s);
++
++ // returns the index to the last byte of the request, or -1 if the buffer
++ // does not contain a full http request
++ int SIMULATOR_DECL find_request_len(char const* buf, int len);
++
++ struct http_request
++ {
++ std::string method;
++ std::string req;
++ std::string path;
++ std::map<std::string, std::string> headers;
++ };
++
++ http_request parse_request(char const* start, int len);
++
++ // builds an HTTP response buffer
++ std::string SIMULATOR_DECL send_response(int code, char const* status_message
++ , int len = 0, char const** extra_header = NULL);
++
++// This is a very simple http server that only supports a single concurrent
++// connection
++struct SIMULATOR_DECL http_server
++{
++ enum flags_t
++ {
++ keep_alive = 1,
++ // behave like an HTTP/1.0 server: respond with an HTTP/1.0 status line
++ // and close the connection after each response. HTTP/1.0 has no
++ // persistent connections, and the Connection header is an HTTP/1.1
++ // mechanism, so no "Connection: close" is sent -- the client must detect
++ // the close from the protocol version (and the socket closing).
++ http_1_0 = 2
++ };
++
++ http_server(asio::io_context& ios, unsigned short listen_port
++ , int flags = http_server::keep_alive);
++
++ void stop();
++
++ using handler_t = std::function<std::string (std::string, std::string
++ , std::map<std::string, std::string>&)>;
++ using generator_t = std::function<std::string (std::int64_t, std::int64_t)>;
++
++ void register_handler(std::string const& path, handler_t h);
++ void register_content(std::string const& path
++ , std::int64_t const size, generator_t gen);
++ void register_redirect(std::string const& path, std::string const& target);
++ void register_stall_handler(std::string const& path);
++
++ // the number of TCP connections that have been accepted so far
++ int accepted_connections() const { return m_accepted_connections; }
++
++private:
++
++ void on_accept(boost::system::error_code const& ec);
++ void read();
++ void on_read(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
++ , bool close);
++ void close_connection();
++
++ asio::io_context& m_ios;
++
++ asio::ip::tcp::acceptor m_listen_socket;
++
++ asio::ip::tcp::socket m_connection;
++ asio::ip::tcp::endpoint m_ep;
++
++ std::unordered_map<std::string, handler_t> m_handlers;
++ std::set<std::string> m_stall_handlers;
++
++ // read buffer, we receive bytes into this buffer for the connection
++ std::string m_recv_buffer;
++
++ // the number of bytes of m_recv_buffer that we've actually read data into.
++ // The remaining is uninitialized, possibly being read into in an async call
++ int m_bytes_used;
++
++ std::string m_send_buffer;
++
++ // set to true when shutting down
++ bool m_close;
++
++ int m_flags;
++
++ // counts the number of accepted TCP connections
++ int m_accepted_connections = 0;
++};
++
++}
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/mallocator.hpp
+@@ -0,0 +1,69 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SIMULATOR_MALLOCATOR_HPP_INCLUDED
++#define SIMULATOR_MALLOCATOR_HPP_INCLUDED
++
++namespace sim
++{
++namespace aux
++{
++ struct channel;
++ struct packet;
++ struct pcap;
++
++ template <typename T>
++ struct mallocator
++ {
++ template <typename U>
++ friend struct mallocator;
++
++ using value_type = T;
++ using pointer = T*;
++ using const_pointer = T const*;
++ using reference = T&;
++ using const_reference = T const&;
++ using size_type = std::size_t;
++ using difference_type = std::ptrdiff_t;
++
++ template <class U>
++ struct rebind {
++ using other = mallocator<U>;
++ };
++
++ mallocator() = default;
++ template <typename U>
++ mallocator(mallocator<U> const&) {}
++
++ T* allocate(std::size_t size)
++ { return reinterpret_cast<T*>(std::malloc(size * sizeof(T))); }
++
++ void deallocate(T* ptr) { std::free(ptr); }
++ void deallocate(T* ptr, std::size_t) { std::free(ptr); }
++
++ void destroy(pointer p) { p->~T(); }
++ void construct(pointer p, T&& value) { new (p) T(std::move(value)); }
++
++ bool operator==(mallocator const&) const { return true; }
++ bool operator!=(mallocator const&) const { return false; }
++ };
++} // aux
++} // sim
++
++#endif // SIMULATOR_MALLOCATOR_HPP_INCLUDED
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/nat.hpp
+@@ -0,0 +1,51 @@
++/*
++
++Copyright (c) 2018, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef NAT_HPP_INCLUDED
++#define NAT_HPP_INCLUDED
++
++#include "simulator/sink.hpp"
++#include "simulator/simulator.hpp"
++#include <string>
++
++namespace sim {
++
++namespace aux {
++ struct packet;
++}
++
++ struct SIMULATOR_DECL nat : sink
++ {
++ nat(asio::ip::address external_addr);
++ ~nat() = default;
++
++ void incoming_packet(aux::packet p) override;
++
++ // used for visualization
++ std::string label() const override;
++
++ private:
++
++ asio::ip::address m_external_addr;
++ };
++
++} // sim
++
++#endif
++
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/noexcept_movable.hpp
+@@ -0,0 +1,56 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef NOEXCEPT_MOVABLE_HPP_INCLUDED
++#define NOEXCEPT_MOVABLE_HPP_INCLUDED
++
++namespace sim {
++namespace aux {
++
++ template <typename T>
++ struct noexcept_movable : T
++ {
++ noexcept_movable() noexcept {}
++ noexcept_movable(noexcept_movable<T>&& rhs) noexcept
++ : T(std::forward<T>(rhs))
++ {}
++ noexcept_movable(noexcept_movable<T> const& rhs)
++ : T(static_cast<T const&>(rhs))
++ {}
++ noexcept_movable(T&& rhs) noexcept : T(std::forward<T>(rhs)) {} // NOLINT
++ noexcept_movable(T const& rhs) : T(rhs) {} // NOLINT
++ noexcept_movable& operator=(noexcept_movable&& rhs) noexcept
++ {
++ this->T::operator=(std::forward<T>(rhs));
++ return *this;
++ }
++ noexcept_movable& operator=(noexcept_movable const& rhs)
++ {
++ this->T::operator=(rhs);
++ return *this;
++ }
++
++ using T::T;
++ using T::operator=;
++ };
++
++}
++}
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/packet.hpp
+@@ -0,0 +1,94 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef PACKET_HPP_INCLUDED
++#define PACKET_HPP_INCLUDED
++
++#include "simulator/config.hpp"
++#include "simulator/simulator.hpp" // for route, endpoint
++
++namespace sim { namespace aux {
++
++ struct channel;
++
++ struct packet
++ {
++ packet() = default;
++
++ // this is move-only
++ packet(packet const&) = delete;
++ packet& operator=(packet const&) = delete;
++ packet(packet&&) = default;
++ packet& operator=(packet&&) = default;
++
++ // to keep things simple, don't drop ACKs or errors
++ bool ok_to_drop() const
++ {
++ return type != type_t::syn_ack
++ && type != type_t::ack
++ && type != type_t::error;
++ }
++
++ enum class type_t
++ {
++ uninitialized, // invalid type (used for debugging)
++ syn, // TCP connect
++ syn_ack, // TCP connection accepted
++ ack, // the seq_nr is interpreted as "we received this"
++ error, // the error_code (ec) is set
++ payload // the buffer is filled
++ };
++
++ type_t type = type_t::uninitialized;
++
++ boost::system::error_code ec;
++
++ // actual payload
++ std::vector<boost::uint8_t> buffer;
++
++ // used for UDP packets
++ asio::ip::udp::endpoint from;
++
++ // the number of bytes of overhead for this packet. The total packet
++ // size is the number of bytes in the buffer + this number
++ int overhead = 20;
++
++ // each hop in the route will pop itself off and forward the packet to
++ // the next hop
++ route hops;
++
++ // for SYN packets, this is set to the channel we're trying to
++ // establish
++ std::shared_ptr<aux::channel> channel;
++
++ // sequence number of this packet (used for debugging)
++ std::uint64_t seq_nr = 0;
++
++ // the number of (payload) bytes sent over this channel so far. This is
++ // meant to map to the TCP sequence number
++ std::uint32_t byte_counter = 0;
++
++ // this function must be called with this packet in case the packet is
++ // dropped.
++ aux::function<void(aux::packet)> drop_fun;
++ };
++
++}} // sim
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/pcap.hpp
+@@ -0,0 +1,42 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef PCAP_HPP_INCLUDED
++#define PCAP_HPP_INCLUDED
++
++#include <fstream>
++#include "simulator/simulator.hpp" // for endpoint
++
++namespace sim { namespace aux
++{
++ struct packet;
++
++ struct pcap
++ {
++ pcap(char const* filename);
++ void log_tcp(packet const& p, asio::ip::tcp::endpoint src
++ , asio::ip::tcp::endpoint dst);
++ void log_udp(packet const& p, asio::ip::udp::endpoint src
++ , asio::ip::udp::endpoint dst);
++ private:
++ std::fstream m_file;
++ };
++}}
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/pop_warnings.hpp
+@@ -0,0 +1,44 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#ifdef __clang__
++#pragma clang diagnostic pop
++#endif
++
++#ifdef __GNUC__
++#pragma GCC diagnostic pop
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/push_warnings.hpp
+@@ -0,0 +1,89 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++ * Redistributions of source code must retain the above copyright
++ notice, this list of conditions and the following disclaimer.
++ * Redistributions in binary form must reproduce the above copyright
++ notice, this list of conditions and the following disclaimer in
++ the documentation and/or other materials provided with the distribution.
++ * Neither the name of the author nor the names of its
++ contributors may be used to endorse or promote products derived
++ from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGE.
++
++*/
++
++#ifdef __GNUC__
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-Wall"
++#pragma GCC diagnostic ignored "-Wsign-conversion"
++#pragma GCC diagnostic ignored "-Wconversion"
++#pragma GCC diagnostic ignored "-Wswitch-enum"
++#pragma GCC diagnostic ignored "-Wold-style-cast"
++#pragma GCC diagnostic ignored "-Wundef"
++#pragma GCC diagnostic ignored "-Wmissing-noreturn"
++#pragma GCC diagnostic ignored "-Wdeprecated"
++#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
++#pragma GCC diagnostic ignored "-Wshadow"
++#pragma GCC diagnostic ignored "-Wunused-variable"
++#pragma GCC diagnostic ignored "-Wpedantic"
++#if __GNUC__ >= 6
++#pragma GCC diagnostic ignored "-Wshift-overflow"
++#pragma GCC diagnostic ignored "-Wshift-count-overflow"
++#pragma GCC diagnostic ignored "-Wshift-count-negative"
++#endif
++#endif
++
++#ifdef __clang__
++#pragma clang diagnostic push
++#pragma clang diagnostic ignored "-Wall"
++#pragma clang diagnostic ignored "-Weverything"
++#pragma clang diagnostic ignored "-Wsign-conversion"
++#pragma clang diagnostic ignored "-Wconversion"
++#pragma clang diagnostic ignored "-Wswitch-enum"
++#pragma clang diagnostic ignored "-Wcovered-switch-default"
++#pragma clang diagnostic ignored "-Wold-style-cast"
++#pragma clang diagnostic ignored "-Wundef"
++#pragma clang diagnostic ignored "-Wweak-vtables"
++#pragma clang diagnostic ignored "-Wmissing-noreturn"
++#pragma clang diagnostic ignored "-Wdeprecated"
++#pragma clang diagnostic ignored "-Wdeprecated-declarations"
++#pragma clang diagnostic ignored "-Wcast-align"
++#pragma clang diagnostic ignored "-Wweak-vtable"
++#pragma clang diagnostic ignored "-Wundef"
++#pragma clang diagnostic ignored "-Wshadow"
++#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
++#pragma clang diagnostic ignored "-Wc++11-long-long"
++#pragma clang diagnostic ignored "-Wc++11-extensions"
++#pragma clang diagnostic ignored "-Wextra-semi"
++#pragma clang diagnostic ignored "-Wunused-parameter"
++#pragma clang diagnostic ignored "-Wreserved-id-macro"
++#pragma clang diagnostic ignored "-Wunused-local-typedef"
++#pragma clang diagnostic ignored "-Wgnu-folding-constant"
++#pragma clang diagnostic ignored "-Wdouble-promotion"
++#pragma clang diagnostic ignored "-Wfloat-equal"
++#endif
++
++#ifdef _MSC_VER
++#pragma warning(push, 1)
++// warning C4005: macro redefinition
++#pragma warning( disable : 4005 )
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/queue.hpp
+@@ -0,0 +1,100 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef QUEUE_HPP_INCLUDED
++#define QUEUE_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++#include "simulator/mallocator.hpp"
++
++#ifdef _MSC_VER
++#pragma warning(push)
++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
++#pragma warning( disable : 4251)
++#endif
++
++namespace sim {
++
++ struct timed_packet
++ {
++ timed_packet(chrono::high_resolution_clock::time_point t, aux::packet p)
++ : ts(t), pkt(std::move(p))
++ {}
++ timed_packet(timed_packet&&) = default;
++ timed_packet& operator=(timed_packet&&) = default;
++ timed_packet(timed_packet const&) = delete;
++ timed_packet& operator=(timed_packet const&) = delete;
++ chrono::high_resolution_clock::time_point ts;
++ aux::packet pkt;
++ };
++
++ // this is a queue. It can be configured to contrain
++ struct SIMULATOR_DECL queue : sink
++ {
++ queue(asio::io_context& ios, int bandwidth
++ , chrono::high_resolution_clock::duration propagation_delay
++ , int max_queue_size, std::string name = "queue");
++
++ virtual void incoming_packet(aux::packet p) override final;
++
++ virtual std::string label() const override final;
++
++ queue(queue const&) = delete;
++ queue& operator=(queue const&) = delete;
++
++ queue(queue&&) = default;
++ queue& operator=(queue&&) = delete;
++
++ private:
++
++ void begin_send_next_packet();
++ void next_packet_sent();
++
++ // the queue can't hold more than this number of bytes. Once it's full,
++ // any new packets arriving will be dropped (tail drop)
++ int m_max_queue_size;
++
++ // the amount of time it takes to forward a packet. Every packet is
++ // delayed by at least this much before being forwarded
++ chrono::high_resolution_clock::duration m_forwarding_latency;
++
++ // the number of bytes per second that can be sent. This includes the
++ // packet overhead
++ int m_bandwidth;
++
++ // the number of bytes currently in the packet queue
++ int m_queue_size;
++
++ std::string m_node_name;
++
++ // this is the queue of packets and the time each packet was enqueued
++ std::deque<timed_packet, aux::mallocator<timed_packet>> m_queue;
++ asio::high_resolution_timer m_forward_timer;
++
++ chrono::high_resolution_clock::time_point m_last_forward;
++ };
++
++}
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/simulator.hpp
+@@ -0,0 +1,1486 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SIMULATOR_HPP_INCLUDED
++#define SIMULATOR_HPP_INCLUDED
++
++#include "simulator/push_warnings.hpp"
++
++#include <boost/config.hpp>
++#include <boost/asio/detail/config.hpp>
++#include <boost/asio/basic_deadline_timer.hpp>
++#include <boost/asio/ip/udp.hpp>
++#include <boost/asio/ip/tcp.hpp>
++#include <boost/asio/write.hpp>
++#include <boost/asio/read.hpp>
++#include <boost/asio/io_context.hpp>
++#include <boost/system/error_code.hpp>
++#include <boost/asio/ip/network_v4.hpp>
++#include <boost/asio/buffers_iterator.hpp>
++
++#include <boost/asio/post.hpp>
++#include <boost/asio/defer.hpp>
++#include <boost/asio/dispatch.hpp>
++#include <boost/asio/error.hpp>
++
++// only for boost::beast::role_type, used by the teardown()/async_teardown()
++// overloads below (customization points boost::beast::websocket::stream
++// needs for any non-boost::asio socket type it's instantiated over); this
++// is the single lightweight header that defines it, not a dependency on
++// beast's websocket/http machinery.
++#include <boost/beast/core/role.hpp>
++
++#include <boost/optional.hpp>
++
++#include "simulator/pop_warnings.hpp"
++
++#include "simulator/chrono.hpp"
++#include "simulator/sink_forwarder.hpp"
++#include "simulator/function.hpp"
++#include "simulator/noexcept_movable.hpp"
++#include "simulator/mallocator.hpp"
++
++#include <deque>
++#include <memory>
++#include <mutex>
++#include <map>
++#include <unordered_map>
++#include <unordered_set>
++#include <set>
++#include <vector>
++#include <list>
++#include <functional>
++#include <utility>
++
++#ifndef IP_DONTFRAGMENT
++#define IP_DONTFRAGMENT 1
++#endif
++
++namespace sim
++{
++ namespace aux
++ {
++ struct channel;
++ struct packet;
++ struct pcap;
++
++ // this is outgoing NIC bandwidth
++ constexpr int nic_bandwidth = 100000000; // 100 MB/s
++ }
++
++ // this represents a network route (a series of sinks to pass a packet
++ // through)
++ struct SIMULATOR_DECL route
++ {
++ friend route operator+(route lhs, route rhs)
++ { return std::move(lhs.append(std::move(rhs))); }
++
++ std::shared_ptr<sink> next_hop() const { return hops.front(); }
++ std::shared_ptr<sink> pop_front()
++ {
++ if (hops.empty()) return std::shared_ptr<sink>();
++ std::shared_ptr<sink> ret(std::move(hops.front()));
++ hops.erase(hops.begin());
++ return ret;
++ }
++ void replace_last(std::shared_ptr<sink> s) { hops.back() = std::move(s); }
++ void prepend(route const& r)
++ { hops.insert(hops.begin(), r.hops.begin(), r.hops.end()); }
++ void prepend(std::shared_ptr<sink> s) { hops.insert(hops.begin(), std::move(s)); }
++ route& append(route const& r)
++ { hops.insert(hops.end(), r.hops.begin(), r.hops.end()); return *this; }
++ route& append(std::shared_ptr<sink> s) { hops.push_back(std::move(s)); return *this; }
++ bool empty() const { return hops.empty(); }
++ std::shared_ptr<sink> last() const
++ { return hops.back(); }
++
++ private:
++ std::deque<std::shared_ptr<sink>, aux::mallocator<std::shared_ptr<sink>>> hops;
++ };
++
++ void forward_packet(aux::packet p);
++
++ struct simulation;
++ struct configuration;
++ struct queue;
++
++ namespace asio
++ {
++
++ using boost::asio::buffer_size;
++ using boost::asio::const_buffer;
++ using boost::asio::mutable_buffer;
++ using boost::asio::buffer;
++
++ // brought in here (rather than relying on ADL at each call site below)
++ // so buffer sequence types whose associated namespaces don't include
++ // boost::asio (e.g. boost::beast's internal buffer sequence types) are
++ // still found; the "using" also participates in ADL's overload set at
++ // the point of an unqualified call, so this doesn't shadow lookups for
++ // types that do live in boost::asio.
++ using boost::asio::buffer_sequence_begin;
++ using boost::asio::buffer_sequence_end;
++
++ using boost::asio::post;
++ using boost::asio::dispatch;
++ using boost::asio::defer;
++
++ struct io_context;
++
++ struct io_executor
++ {
++ io_executor(io_context& ctx) : m_ctx(&ctx) {}
++ io_context& context() const { return *m_ctx; }
++
++ template <typename Handler, typename Allocator>
++ void dispatch(Handler handler, Allocator const& a) const;
++
++ template <typename Handler, typename Allocator>
++ void post(Handler handler, Allocator const& a) const;
++
++ template <typename Handler, typename Allocator>
++ void defer(Handler handler, Allocator const& a) const;
++
++ void on_work_finished() const {}
++ void on_work_started() const {}
++
++ bool running_in_this_thread() const { return true; }
++
++ friend bool operator==(io_executor const& lhs, io_executor const& rhs)
++ { return lhs.m_ctx == rhs.m_ctx; }
++
++ friend bool operator!=(io_executor const& lhs, io_executor const& rhs)
++ { return lhs.m_ctx != rhs.m_ctx; }
++
++ private:
++ io_context* m_ctx;
++ };
++
++ struct SIMULATOR_DECL high_resolution_timer
++ {
++ friend struct sim::simulation;
++
++ using time_type = chrono::high_resolution_clock::time_point;
++ using duration_type = chrono::high_resolution_clock::duration;
++
++ using executor_type = io_executor;
++ executor_type get_executor();
++
++ explicit high_resolution_timer(io_context& io_context);
++ high_resolution_timer(io_context& io_context,
++ const time_type& expiry_time);
++ high_resolution_timer(io_context& io_context,
++ const duration_type& expiry_time);
++ high_resolution_timer(high_resolution_timer&&) noexcept = default;
++ high_resolution_timer& operator=(high_resolution_timer&&) noexcept = default;
++ ~high_resolution_timer();
++
++ std::size_t cancel();
++ std::size_t cancel_one();
++
++ time_type expiry() const;
++ std::size_t expires_at(const time_type& expiry_time);
++ std::size_t expires_after(const duration_type& expiry_time);
++
++ void wait();
++ void wait(boost::system::error_code& ec);
++
++ void async_wait(aux::function<void(boost::system::error_code const&)> handler);
++
++ private:
++
++ void fire(boost::system::error_code ec);
++
++ time_type m_expiration_time;
++ aux::function<void(boost::system::error_code const&)> m_handler;
++ io_context* m_io_service;
++ bool m_expired;
++ };
++
++ using waitable_timer = high_resolution_timer;
++
++ namespace error = boost::asio::error;
++
++ template <typename Protocol>
++ struct socket_base
++ {
++ socket_base(io_context& ios) : m_io_service(ios) {}
++ socket_base(socket_base&& s) = default;
++
++ enum wait_type_t
++ {
++ wait_read, wait_write, wait_error
++ };
++
++ // alias matching the name used by boost.asio's basic_socket::wait_type,
++ // for code that's written against both APIs
++ using wait_type = wait_type_t;
++
++ // io_control
++ using reuse_address = boost::asio::socket_base::reuse_address;
++ using executor_type = io_executor;
++ executor_type get_executor();
++
++ // socket options
++ using send_buffer_size = boost::asio::socket_base::send_buffer_size;
++ using receive_buffer_size = boost::asio::socket_base::receive_buffer_size;
++
++ template <class Option>
++ void set_option(Option const& opt, boost::system::error_code&)
++ {
++ Protocol const p = Protocol::v4();
++ (void)p;
++#ifdef IP_DONTFRAG
++ if (opt.name(p) == IP_DONTFRAG)
++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
++#endif
++#ifdef IP_DONTFRAGMENT
++ if (opt.name(p) == IP_DONTFRAGMENT)
++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
++#endif
++#ifdef IP_MTU_DISCOVER
++ if (opt.name(p) == IP_MTU_DISCOVER)
++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) == IP_PMTUDISC_DO;
++#endif
++ }
++
++ void set_option(receive_buffer_size const& op, boost::system::error_code&)
++ {
++ m_max_receive_queue_size = op.value();
++ }
++
++ void set_option(send_buffer_size const& op, boost::system::error_code&)
++ {
++ // this limit is specified in microseconds. Given the line rate of
++ // nic_bandwidth, this is the time it takes to send the specified number
++ // of bytes.
++ m_send_queue_time = chrono::microseconds(std::int64_t(double(op.value()) * 1000000.0 / double(aux::nic_bandwidth)));
++ }
++
++ void set_option(reuse_address const&, boost::system::error_code&)
++ {
++ // TODO: implement
++ }
++
++ typename Protocol::endpoint local_endpoint(boost::system::error_code& ec) const
++ {
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return typename Protocol::endpoint{};
++ }
++
++ return m_user_bound_to;
++ }
++
++ typename Protocol::endpoint local_endpoint() const
++ {
++ boost::system::error_code ec;
++ auto const ret = local_endpoint(ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ typename Protocol::endpoint local_bound_to(boost::system::error_code& ec) const
++ {
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return typename Protocol::endpoint{};
++ }
++
++ return m_bound_to;
++ }
++
++ typename Protocol::endpoint local_bound_to() const
++ {
++ boost::system::error_code ec;
++ auto const ret = local_bound_to(ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ template <class Option>
++ void get_option(Option&, boost::system::error_code&) { }
++
++ void get_option(receive_buffer_size& op, boost::system::error_code&)
++ {
++ op = m_max_receive_queue_size;
++ }
++
++ template <class IoControl>
++ void io_control(IoControl const&, boost::system::error_code&) { }
++
++ template <class IoControl>
++ void io_control(IoControl const&) {}
++
++ void non_blocking(bool b, boost::system::error_code&)
++ { m_non_blocking = b; }
++
++ void non_blocking(bool b)
++ { m_non_blocking = b; }
++
++ bool is_open() const
++ {
++ return m_open;
++ }
++
++ using message_flags = int;
++
++ // internal interface
++
++ route get_incoming_route();
++ route get_outgoing_route();
++
++ protected:
++
++ io_context& m_io_service;
++
++ typename Protocol::endpoint m_bound_to;
++
++ // this is the interface the user requested to bind to (in order to
++ // distinguish the concrete interface it was bound to and INADDR_ANY if
++ // that was requested). We keep this separately to return it as the local
++ // endpoint
++ typename Protocol::endpoint m_user_bound_to;
++
++ // this is an object implementing the sink interface, forwarding
++ // packets to this socket. If this socket is destructed, this forwarder
++ // is redirected to just drop packets. This is necessary since sinks
++ // must be held by shared_ptr, and socket objects aren't.
++ std::shared_ptr<aux::sink_forwarder> m_forwarder;
++
++ // whether the socket is open or not
++ bool m_open = false;
++
++ // true if the socket is set to non-blocking mode
++ bool m_non_blocking = false;
++
++ // when true, the MTU limit is in effect
++ bool m_dont_fragment = false;
++
++ // the max size of the incoming queue. This is to emulate the send and
++ // receive buffer. This should also depend on the bandwidth, to not
++ // make the queue size not grow too long in time.
++ int m_max_receive_queue_size = 64 * 1024;
++
++ // the number of microseconds worth of send buffer this socket has, at
++ // NIC linerate.
++ chrono::microseconds m_send_queue_time{200000};
++ };
++
++ namespace ip {
++
++ using boost::asio::ip::address;
++ using boost::asio::ip::address_v4;
++ using boost::asio::ip::address_v6;
++
++ using boost::asio::ip::make_address_v4;
++ using boost::asio::ip::make_address_v6;
++ using boost::asio::ip::make_address;
++
++ using boost::asio::ip::make_network_v4;
++
++ template<typename Protocol>
++ struct basic_endpoint : boost::asio::ip::basic_endpoint<Protocol>
++ {
++ basic_endpoint(ip::address const& addr, unsigned short port)
++ : boost::asio::ip::basic_endpoint<Protocol>(addr, port) {}
++ basic_endpoint() : boost::asio::ip::basic_endpoint<Protocol>() {}
++ };
++
++ template <typename Protocol>
++ struct basic_resolver_entry
++ {
++ using endpoint_type = typename Protocol::endpoint;
++ using protocol_type = Protocol;
++
++ basic_resolver_entry() {}
++ basic_resolver_entry(
++ endpoint_type const& ep
++ , std::string const& host
++ , std::string const& service)
++ : m_endpoint(ep)
++ , m_host_name(host)
++ , m_service(service)
++ {}
++
++ endpoint_type endpoint() const { return m_endpoint; }
++ std::string host_name() const { return m_host_name; }
++ operator endpoint_type() const { return m_endpoint; }
++ std::string service_name() const { return m_service; }
++
++ private:
++ endpoint_type m_endpoint;
++ std::string m_host_name;
++ std::string m_service;
++ };
++
++ template<typename Protocol>
++ struct SIMULATOR_DECL basic_resolver
++ {
++ basic_resolver(io_context& ios);
++
++ using protocol_type = Protocol;
++ using results_type = std::vector<basic_resolver_entry<Protocol>, aux::mallocator<basic_resolver_entry<Protocol>>>;
++
++ void cancel();
++
++ void async_resolve(std::string hostname, char const* service
++ , aux::function<void(boost::system::error_code const&,
++ results_type)> handler);
++
++ basic_resolver(basic_resolver&&) noexcept;
++ basic_resolver& operator=(basic_resolver&&) noexcept;
++ basic_resolver(basic_resolver const&) = delete;
++ basic_resolver& operator=(basic_resolver const&) = delete;
++
++ //TODO: add remaining members
++
++ private:
++
++ void on_lookup(boost::system::error_code const& ec);
++
++ struct result_t
++ {
++ chrono::high_resolution_clock::time_point completion_time;
++ boost::system::error_code err;
++ results_type ips;
++ aux::function<void(boost::system::error_code const&,
++ results_type)> handler;
++
++ result_t(
++ chrono::high_resolution_clock::time_point ct
++ , boost::system::error_code e
++ , results_type ips_
++ , aux::function<void(boost::system::error_code const&
++ , results_type)> h)
++ : completion_time(ct)
++ , err(e)
++ , ips(std::move(ips_))
++ , handler(std::move(h))
++ {}
++
++ result_t(result_t&&) noexcept = default;
++ result_t& operator=(result_t&&) = default;
++ result_t(result_t const&) = delete;
++ result_t& operator=(result_t const&) = delete;
++ };
++
++ io_context* m_ios;
++ asio::high_resolution_timer m_timer;
++ using queue_t = aux::noexcept_movable<std::vector<result_t>>;
++
++ queue_t m_queue;
++ };
++
++ struct SIMULATOR_DECL udp
++ {
++ static udp v4() { return udp(AF_INET); }
++ static udp v6() { return udp(AF_INET6); }
++
++ using endpoint = basic_endpoint<udp>;
++
++ struct SIMULATOR_DECL socket : socket_base<udp>, sink
++ {
++ using endpoint_type = ip::udp::endpoint;
++ using protocol_type = ip::udp;
++ using lowest_layer_type = socket;
++
++ socket(io_context& ios);
++ ~socket() override;
++
++ socket(socket const&) = delete;
++ socket& operator=(socket const&) = delete;
++ socket(socket&&);
++
++ lowest_layer_type& lowest_layer() { return *this; }
++
++ void bind(ip::udp::endpoint const& ep
++ , boost::system::error_code& ec);
++ void bind(ip::udp::endpoint const& ep);
++
++ void close();
++ void close(boost::system::error_code& ec);
++
++ void cancel(boost::system::error_code& ec);
++ void cancel();
++
++ void open(udp protocol, boost::system::error_code& ec);
++ void open(udp protocol);
++
++ template<typename ConstBufferSequence>
++ std::size_t send_to(ConstBufferSequence const& bufs
++ , udp::endpoint const& destination
++ , socket_base::message_flags flags
++ , boost::system::error_code& ec)
++ {
++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs)
++ , buffer_sequence_end(bufs));
++ abort_send_handlers();
++ return send_to_impl(b, destination, flags, ec);
++ }
++
++ template<typename ConstBufferSequence>
++ std::size_t send_to(ConstBufferSequence const& bufs
++ , udp::endpoint const& destination)
++ {
++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_send_handlers();
++ boost::system::error_code ec;
++ std::size_t ret = send_to_impl(b, destination, 0, ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ void async_wait(socket_base::wait_type_t w
++ , aux::function<void(boost::system::error_code const&)> handler);
++
++ template <class BufferSequence>
++ void async_receive(BufferSequence const& bufs
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_recv_handlers();
++
++ async_receive_from_impl(b, nullptr, 0, std::move(handler));
++ }
++
++ template <class BufferSequence>
++ void async_receive_from(BufferSequence const& bufs
++ , udp::endpoint& sender
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_recv_handlers();
++
++ async_receive_from_impl(b, &sender, 0, std::move(handler));
++ }
++
++ template <class BufferSequence>
++ void async_receive_from(BufferSequence const& bufs
++ , udp::endpoint& sender
++ , socket_base::message_flags flags
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_recv_handlers();
++
++ async_receive_from_impl(b, &sender, flags, std::move(handler));
++ }
++/*
++ void async_read_from(null_buffers const&
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ abort_recv_handlers();
++ async_read_some_null_buffers_impl(std::move(handler));
++ }
++*/
++
++ template <class BufferSequence>
++ std::size_t receive_from(BufferSequence const& bufs
++ , udp::endpoint& sender)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ assert(!b.empty());
++ abort_recv_handlers();
++ boost::system::error_code ec;
++ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ template <class BufferSequence>
++ std::size_t receive_from(BufferSequence const& bufs
++ , udp::endpoint& sender
++ , socket_base::message_flags)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ assert(!b.empty());
++ abort_recv_handlers();
++ boost::system::error_code ec;
++ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ template <class BufferSequence>
++ std::size_t receive_from(BufferSequence const& bufs
++ , udp::endpoint& sender
++ , socket_base::message_flags
++ , boost::system::error_code& ec)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ assert(!b.empty());
++ abort_recv_handlers();
++ return receive_from_impl(b, &sender, 0, ec);
++ }
++
++ // TODO: support connect and remote_endpoint
++
++ // internal interface
++
++ // implements sink
++ virtual void incoming_packet(aux::packet p) override final;
++ virtual std::string label() const override final
++ { return m_bound_to.address().to_string(); }
++
++ void async_receive_from_impl(std::vector<asio::mutable_buffer> const& bufs
++ , udp::endpoint* sender
++ , socket_base::message_flags flags
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler);
++
++ std::size_t receive_from_impl(
++ std::vector<asio::mutable_buffer> const& bufs
++ , udp::endpoint* sender
++ , socket_base::message_flags flags
++ , boost::system::error_code& ec);
++
++ void async_wait_receive_impl(
++ udp::endpoint* sender
++ , aux::function<void(boost::system::error_code const&)> handler);
++
++ private:
++
++ void maybe_wakeup_reader();
++ void abort_send_handlers();
++ void abort_recv_handlers();
++
++ std::size_t send_to_impl(std::vector<asio::const_buffer> const& b
++ , udp::endpoint const& dst, message_flags flags
++ , boost::system::error_code& ec);
++
++ // this is the next time we'll have an opportunity to send another
++ // outgoing packet. This is used to implement the bandwidth constraints
++ // of channels. This may be in the past, in which case it's OK to send
++ // a packet immediately.
++ chrono::high_resolution_clock::time_point m_next_send;
++
++ // while we're blocked in an async_write_some operation, this is the
++ // handler that should be called once we're done sending
++ aux::function<void(boost::system::error_code const&, std::size_t)>
++ m_send_handler;
++ aux::function<void(boost::system::error_code const&)>
++ m_wait_send_handler;
++
++ // if we have an outstanding read on this socket, this is set to the
++ // handler.
++ aux::function<void(boost::system::error_code const&, std::size_t)>
++ m_recv_handler;
++ aux::function<void(boost::system::error_code const&)>
++ m_wait_recv_handler;
++
++ // if we have an outstanding read operation, this is the buffer to
++ // receive into
++ std::vector<asio::mutable_buffer> m_recv_buffer;
++
++ // if we have an outstanding receive operation, this may point to an
++ // endpoint to fill in the senders IP in
++ udp::endpoint* m_recv_sender;
++
++ asio::high_resolution_timer m_recv_timer;
++ asio::high_resolution_timer m_send_timer;
++
++ // this is the incoming queue of packets for each socket
++ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
++
++ bool m_recv_null_buffers;
++
++ // the number of bytes in the incoming packet queue
++ int m_queue_size;
++
++ // our address family
++ bool m_is_v4;
++ };
++
++ using resolver = basic_resolver<udp>;
++
++ int family() const { return m_family; }
++
++ friend bool operator==(udp const& lhs, udp const& rhs)
++ { return lhs.m_family == rhs.m_family; }
++
++ friend bool operator!=(udp const& lhs, udp const& rhs)
++ { return lhs.m_family != rhs.m_family; }
++
++ private:
++ // Construct with a specific family.
++ explicit udp(int protocol_family)
++ : m_family(protocol_family)
++ {}
++
++ int m_family;
++
++ }; // udp
++
++ struct SIMULATOR_DECL tcp
++ {
++ // temporary fix until the resolvers are implemented using our endpoint
++ tcp(boost::asio::ip::tcp p) : m_family(p.family()) {}
++
++ static tcp v4() { return tcp(AF_INET); }
++ static tcp v6() { return tcp(AF_INET6); }
++
++ int family() const { return m_family; }
++
++ using endpoint = basic_endpoint<tcp>;
++
++ struct SIMULATOR_DECL socket : socket_base<tcp>, sink
++ {
++ using endpoint_type = ip::tcp::endpoint;
++ using protocol_type = ip::tcp;
++ using lowest_layer_type = socket;
++
++ explicit socket(io_context& ios);
++ socket(socket const&) = delete;
++ socket& operator=(socket const&) = delete;
++ socket(socket&&);
++ socket& operator=(socket&&);
++
++ ~socket() override;
++
++ void close();
++ void close(boost::system::error_code& ec);
++ void open(tcp protocol, boost::system::error_code& ec);
++ void open(tcp protocol);
++ void bind(ip::tcp::endpoint const& ep
++ , boost::system::error_code& ec);
++ void bind(ip::tcp::endpoint const& ep);
++ tcp::endpoint remote_endpoint(boost::system::error_code& ec) const;
++ tcp::endpoint remote_endpoint() const;
++
++ lowest_layer_type& lowest_layer() { return *this; }
++
++ void async_connect(tcp::endpoint const& target
++ , aux::function<void(boost::system::error_code const&)> h);
++
++ template <class ConstBufferSequence>
++ void async_write_some(ConstBufferSequence const& bufs
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_send_handlers();
++ async_write_some_impl(b, std::move(handler));
++ }
++
++ void async_wait(socket_base::wait_type_t const w
++ , aux::function<void(boost::system::error_code const&)> handler)
++ {
++ if (w == socket_base::wait_type_t::wait_write)
++ {
++ abort_send_handlers();
++ async_wait_write_impl(std::move(handler));
++ }
++ else if (w == socket_base::wait_type_t::wait_read)
++ {
++ abort_recv_handlers();
++ async_wait_read_impl(std::move(handler));
++ }
++ }
++
++ template <class BufferSequence>
++ std::size_t read_some(BufferSequence const& bufs
++ , boost::system::error_code& ec)
++ {
++ assert(m_non_blocking && "blocking operations not supported");
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ return read_some_impl(b, ec);
++ }
++
++ template <class ConstBufferSequence>
++ std::size_t write_some(ConstBufferSequence const& bufs
++ , boost::system::error_code& ec)
++ {
++ assert(m_non_blocking && "blocking operations not supported");
++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ return write_some_impl(b, ec);
++ }
++
++ template <class BufferSequence>
++ void async_read_some(BufferSequence const& bufs
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
++ abort_recv_handlers();
++
++ async_read_some_impl(b, std::move(handler));
++ }
++
++ std::size_t available(boost::system::error_code & ec) const;
++ std::size_t available() const;
++
++ void cancel(boost::system::error_code& ec);
++ void cancel();
++
++ using socket_base::set_option;
++ using socket_base::get_option;
++ using socket_base::io_control;
++
++ // private interface
++
++ // implements sink
++ virtual void incoming_packet(aux::packet p) override;
++ virtual std::string label() const override final
++ { return m_bound_to.address().to_string(); }
++
++ void internal_connect(tcp::endpoint const& bind_ip
++ , std::shared_ptr<aux::channel> const& c
++ , boost::system::error_code& ec);
++
++ void abort_send_handlers();
++ void abort_recv_handlers();
++
++ virtual bool internal_is_listening();
++ protected:
++
++ void maybe_wakeup_reader();
++ void maybe_wakeup_writer();
++
++ void async_write_some_impl(std::vector<asio::const_buffer> const& bufs
++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
++ void async_read_some_impl(std::vector<asio::mutable_buffer> const& bufs
++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
++ void async_wait_read_impl(
++ aux::function<void(boost::system::error_code const&)> handler);
++ void async_wait_write_impl(
++ aux::function<void(boost::system::error_code const&)> handler);
++ std::size_t write_some_impl(std::vector<asio::const_buffer> const& bufs
++ , boost::system::error_code& ec);
++ std::size_t read_some_impl(std::vector<asio::mutable_buffer> const& bufs
++ , boost::system::error_code& ec);
++
++ void send_packet(aux::packet p);
++
++ // called when a packet is dropped
++ void packet_dropped(aux::packet p);
++
++ aux::function<void(boost::system::error_code const&)> m_connect_handler;
++
++ asio::high_resolution_timer m_connect_timer;
++
++ // the tcp "packet size" (segment size)
++ // TODO: name this constant!
++ int m_mss = 1475;
++
++ // while we're blocked in an async_write_some operation, this is the
++ // handler that should be called once we're done sending
++ aux::function<void(boost::system::error_code const&, std::size_t)> m_send_handler;
++ aux::function<void(boost::system::error_code const&)> m_wait_send_handler;
++
++ std::vector<asio::const_buffer> m_send_buffer;
++
++ // this is the incoming queue of packets for each socket
++ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
++
++ // the number of bytes in the incoming packet queue
++ int m_queue_size = 0;
++
++ // if we have an outstanding read on this socket, this is set to the
++ // handler.
++ aux::function<void(boost::system::error_code const&, std::size_t)> m_recv_handler;
++ aux::function<void(boost::system::error_code const&)> m_wait_recv_handler;
++
++ // if we have an outstanding buffer to receive into, these are them
++ std::vector<asio::mutable_buffer> m_recv_buffer;
++
++ asio::high_resolution_timer m_recv_timer;
++
++ // our address family
++ bool m_is_v4 = true;
++
++ // true if the currently outstanding read operation is for null_buffers
++ bool m_recv_null_buffers = false;
++
++ // true if the currenly outstanding write operation is for null_buffers
++ bool m_send_null_buffers = false;
++
++ // if this socket is connected to another endpoint, this object is
++ // shared between both sockets and contain information and state about
++ // the channel.
++ std::shared_ptr<aux::channel> m_channel;
++
++ std::uint64_t m_next_outgoing_seq = 0;
++ std::uint64_t m_next_incoming_seq = 0;
++
++ // the sequence number of the last dropped packet. We should only cut
++ // the cwnd in half once per round-trip. If a whole window is lost, we
++ // need to only halve it once
++ std::uint64_t m_last_drop_seq = 0;
++
++ // the current congestion window size (in bytes)
++ int m_cwnd = m_mss * 2;
++
++ // the number of bytes that have been sent but not ACKed yet
++ int m_bytes_in_flight = 0;
++
++ // reorder buffer for when packets are dropped
++ std::map<std::uint64_t, aux::packet, std::less<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, aux::packet>>> m_reorder_buffer;
++
++ // the sizes of packets given their sequence number
++ std::unordered_map<std::uint64_t, int, std::hash<std::uint64_t>, std::equal_to<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, int>>> m_outstanding_packet_sizes;
++
++ // packets to re-send (because they were dropped)
++ std::list<aux::packet, aux::mallocator<aux::packet>> m_outgoing_packets;
++ };
++
++ struct SIMULATOR_DECL acceptor : socket
++ {
++ explicit acceptor(io_context& ios);
++ acceptor(acceptor&&);
++ ~acceptor() override;
++
++ void cancel(boost::system::error_code& ec);
++ void cancel();
++
++ void listen(int qs = -1);
++ void listen(int qs, boost::system::error_code& ec);
++
++ void async_accept(ip::tcp::socket& peer
++ , aux::function<void(boost::system::error_code const&)> h);
++ void async_accept(ip::tcp::socket& peer
++ , ip::tcp::endpoint& peer_endpoint
++ , aux::function<void(boost::system::error_code const&)> h);
++ void async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h);
++
++ void close(boost::system::error_code& ec);
++ void close();
++
++ // private interface
++
++ // implements sink
++ virtual void incoming_packet(aux::packet p) override final;
++ virtual bool internal_is_listening() override final;
++
++ private:
++ // check the incoming connection queue to see if any connection in
++ // there is ready to be accepted and delivered to the user
++ void check_accept_queue();
++ void do_check_accept_queue(boost::system::error_code const& ec);
++
++ aux::function<void(boost::system::error_code const&)> m_accept_handler;
++ aux::function<void(boost::system::error_code const&, ip::tcp::socket)> m_accept_handler2;
++
++ // the number of half-open incoming connections this listen socket can
++ // hold. If this is -1, this socket is not yet listening and incoming
++ // connection attempts should be rejected.
++ int m_queue_size_limit;
++
++ // these are incoming connection attempts. Both half-open and
++ // completely connected. When accepting a connection, this queue is
++ // checked first before waiting for a connection attempt.
++ using incoming_conns_t = std::vector<std::shared_ptr<aux::channel>, aux::mallocator<std::shared_ptr<aux::channel>>>;
++ incoming_conns_t m_incoming_conns;
++
++ // for new-style accept, allocate socket in here just to fail early
++ boost::optional<ip::tcp::socket> m_new_socket;
++
++ // the socket to accept a connection into
++ tcp::socket* m_accept_into;
++
++ // the endpoint to write the remote endpoint into when accepting
++ tcp::endpoint* m_remote_endpoint;
++
++ // non copyable
++ acceptor(acceptor const&);
++ acceptor& operator=(acceptor const&);
++ };
++
++ using resolver = basic_resolver<tcp>;
++
++ friend bool operator==(tcp const& lhs, tcp const& rhs)
++ { return lhs.m_family == rhs.m_family; }
++
++ friend bool operator!=(tcp const& lhs, tcp const& rhs)
++ { return lhs.m_family != rhs.m_family; }
++
++ private:
++ // Construct with a specific family.
++ explicit tcp(int protocol_family)
++ : m_family(protocol_family)
++ {}
++
++ int m_family;
++ };
++
++ extern template struct basic_resolver<udp>;
++ extern template struct basic_resolver<tcp>;
++
++ // boost::beast looks up a close function for a socket-like type via
++ // unqualified lookup + ADL under the name "beast_close_socket" (see
++ // boost/beast/core/stream_traits.hpp); this satisfies that customization
++ // point for tcp::socket - it's just a free function beast's ADL-based
++ // lookup will find because it lives in tcp::socket's own namespace, so
++ // beast::websocket::stream<tcp::socket> doesn't need this header to
++ // declare it inside boost::beast itself.
++ inline void beast_close_socket(tcp::socket& s)
++ {
++ boost::system::error_code ec;
++ s.close(ec);
++ }
++
++ // same idea for the teardown()/async_teardown() customization points
++ // boost::beast::websocket::stream<Socket> looks up (via ADL, from
++ // boost::beast::websocket) for any Socket type it's instantiated over
++ // that isn't a boost::asio socket -- see
++ // boost/beast/websocket/teardown.hpp. tcp::socket has no half-close/
++ // non-blocking read-drain support to mirror the real graceful-shutdown
++ // sequence those implement for a real socket, so this just closes it;
++ // that's sufficient for driving deterministic test scenarios, which is
++ // the only thing this socket type is ever used for.
++ inline void teardown(boost::beast::role_type, tcp::socket& s, boost::system::error_code& ec)
++ {
++ s.close(ec);
++ }
++
++ template <class Handler>
++ void async_teardown(boost::beast::role_type, tcp::socket& s, Handler&& handler)
++ {
++ boost::system::error_code ec;
++ s.close(ec);
++ boost::asio::post(s.get_executor(), std::bind(std::forward<Handler>(handler), ec));
++ }
++
++ } // ip
++
++ // mirrors (a subset of) boost::asio::async_connect(socket, begin, end,
++ // handler): tries each endpoint in the range in turn, closing and
++ // advancing to the next on failure, until one connects or the range is
++ // exhausted. Calls handler(error_code, Iterator) with the iterator that
++ // succeeded, or the end iterator carrying the last endpoint's error if
++ // all of them failed. Lives directly in sim::asio, alongside the
++ // boost::asio free function it mirrors, rather than in sim::asio::ip, so
++ // that unqualified calls resolve to whichever of the two applies via
++ // ADL (ip::tcp::socket's base, socket_base<tcp>, is declared in this
++ // namespace, which is what makes that lookup work).
++ template <typename Iterator, typename Handler>
++ void async_connect(ip::tcp::socket& s, Iterator begin, Iterator end, Handler handler)
++ {
++ struct op : std::enable_shared_from_this<op>
++ {
++ op(ip::tcp::socket& sock, Iterator b, Iterator e, Handler h)
++ : socket(sock), iter(b), end(e), handler(std::move(h))
++ {}
++
++ void attempt()
++ {
++ socket.async_connect(*iter, [self = this->shared_from_this()]
++ (boost::system::error_code const& ec) { self->on_connect(ec); });
++ }
++
++ void on_connect(boost::system::error_code const& ec)
++ {
++ if (ec && std::next(iter) != end)
++ {
++ boost::system::error_code ignore;
++ socket.close(ignore);
++ ++iter;
++ attempt();
++ return;
++ }
++
++ handler(ec, iter);
++ }
++
++ ip::tcp::socket& socket;
++ Iterator iter;
++ Iterator end;
++ Handler handler;
++ };
++
++ if (begin == end)
++ {
++ handler(boost::asio::error::make_error_code(boost::asio::error::not_found), end);
++ return;
++ }
++
++ std::make_shared<op>(s, begin, end, std::move(handler))->attempt();
++ }
++
++ } // asio
++
++ struct SIMULATOR_DECL simulation
++ {
++ // it calls fire() when a timer fires
++ friend struct high_resolution_timer;
++
++ simulation(configuration& config);
++ ~simulation();
++
++ std::size_t run();
++
++ std::size_t poll(boost::system::error_code& ec);
++ std::size_t poll();
++
++ std::size_t poll_one(boost::system::error_code& ec);
++ std::size_t poll_one();
++
++ void stop();
++ bool stopped() const;
++ void restart();
++ // private interface
++
++ void add_timer(asio::high_resolution_timer* t);
++ void remove_timer(asio::high_resolution_timer* t);
++
++ boost::asio::io_context& get_internal_service()
++ { return m_service; }
++
++ asio::io_context& get_io_context()
++ { return *m_internal_ios; }
++
++ asio::ip::tcp::endpoint bind_socket(asio::ip::tcp::socket* socket
++ , asio::ip::tcp::endpoint ep
++ , boost::system::error_code& ec);
++ void unbind_socket(asio::ip::tcp::socket* socket
++ , asio::ip::tcp::endpoint const& ep);
++ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
++
++ asio::ip::udp::endpoint bind_udp_socket(asio::ip::udp::socket* socket
++ , asio::ip::udp::endpoint ep
++ , boost::system::error_code& ec);
++ void unbind_udp_socket(asio::ip::udp::socket* socket
++ , asio::ip::udp::endpoint const& ep);
++ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
++
++ std::shared_ptr<aux::channel> internal_connect(asio::ip::tcp::socket* s
++ , asio::ip::tcp::endpoint const& target, boost::system::error_code& ec);
++
++ route find_udp_socket(
++ asio::ip::udp::socket const& socket
++ , asio::ip::udp::endpoint const& ep);
++
++ configuration& config() const { return m_config; }
++
++ void add_io_service(asio::io_context* ios);
++ void remove_io_service(asio::io_context* ios);
++ std::vector<asio::io_context*> get_all_io_services() const;
++
++ aux::pcap* get_pcap() const { return m_pcap.get(); }
++ void log_pcap(char const* filename);
++
++ private:
++ struct timer_compare
++ {
++ bool operator()(asio::high_resolution_timer const* lhs
++ , asio::high_resolution_timer const* rhs) const
++ { return lhs->expiry() < rhs->expiry(); }
++ };
++
++ configuration& m_config;
++
++ std::unique_ptr<aux::pcap> m_pcap;
++
++ // all non-expired timers
++ std::mutex m_timer_queue_mutex;
++ using timer_queue_t = std::vector<asio::high_resolution_timer*, aux::mallocator<asio::high_resolution_timer*>>;
++ timer_queue_t m_timer_queue;
++
++ // these are the io services that represent nodes on the network
++ std::unordered_set<asio::io_context*, std::hash<asio::io_context*>, std::equal_to<asio::io_context*>, aux::mallocator<asio::io_context*>> m_nodes;
++
++ using listen_sockets_t = std::map<asio::ip::tcp::endpoint, asio::ip::tcp::socket*>;
++ using listen_socket_iter_t = listen_sockets_t::iterator;
++ listen_sockets_t m_listen_sockets;
++
++ using udp_sockets_t = std::map<asio::ip::udp::endpoint, asio::ip::udp::socket*>;
++ using udp_socket_iter_t = udp_sockets_t::iterator;
++ udp_sockets_t m_udp_sockets;
++
++ // used for internal timers. this is a pimpl sine our io_context is
++ // incomplete at this point
++ std::unique_ptr<asio::io_context> m_internal_ios;
++
++ // the next port to use for an outgoing connection, where the port is not
++ // specified. We want this to be as unique as possible, to distinguish the
++ // TCP streams.
++ std::uint16_t m_next_bind_port = 2000;
++
++ bool m_stopped = false;
++
++ // underlying message queue
++ boost::asio::io_context m_service;
++ };
++
++ namespace asio {
++
++ using boost::asio::async_write;
++ using boost::asio::async_read;
++
++ // boost.asio compatible io_context class that simulates the network
++ // and time.
++ struct SIMULATOR_DECL io_context : boost::asio::execution_context
++ {
++ io_context(sim::simulation& sim);
++ io_context(sim::simulation& sim, ip::address const& ip);
++ io_context(sim::simulation& sim, std::vector<ip::address> const& ips);
++ io_context(std::size_t threads_hint = 0);
++ ~io_context();
++
++ // not copyable and non movable (it's not movable because we currently
++ // keep pointers to the io_context instances in the simulator object)
++ io_context(io_context const&) = delete;
++ io_context(io_context&&) = delete;
++ io_context& operator=(io_context const&) = delete;
++ io_context& operator=(io_context&&) = delete;
++
++ std::size_t run(boost::system::error_code& ec);
++ std::size_t run();
++
++ std::size_t poll(boost::system::error_code& ec);
++ std::size_t poll();
++
++ std::size_t poll_one(boost::system::error_code& ec);
++ std::size_t poll_one();
++
++ template <typename Rep, typename Period>
++ std::size_t run_for(std::chrono::duration<Rep, Period> const&)
++ {
++ assert(false);
++ return 0;
++ }
++
++ template <typename Rep, typename Period>
++ std::size_t poll_one_for(std::chrono::duration<Rep, Period> const&)
++ {
++ assert(false);
++ return 0;
++ }
++
++ void stop();
++ bool stopped() const;
++ void restart();
++
++ template <typename Handler, typename Allocator>
++ void dispatch_impl(Handler handler, Allocator const& a)
++ { get_internal_service().get_executor().dispatch(std::move(handler), a); }
++
++ template <typename Handler, typename Allocator>
++ void post_impl(Handler handler, Allocator const& a)
++ { get_internal_service().get_executor().post(std::move(handler), a); }
++
++ template <typename Handler, typename Allocator>
++ void defer_impl(Handler handler, Allocator const& a)
++ { get_internal_service().get_executor().defer(std::move(handler), a); }
++
++ // internal interface
++ boost::asio::io_context& get_internal_service();
++
++ void add_timer(high_resolution_timer* t);
++ void remove_timer(high_resolution_timer* t);
++
++ ip::tcp::endpoint bind_socket(ip::tcp::socket* socket, ip::tcp::endpoint ep
++ , boost::system::error_code& ec);
++ void unbind_socket(ip::tcp::socket* socket
++ , ip::tcp::endpoint const& ep);
++ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
++
++ ip::udp::endpoint bind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep
++ , boost::system::error_code& ec);
++ void unbind_udp_socket(ip::udp::socket* socket
++ , ip::udp::endpoint const& ep);
++ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
++
++ std::shared_ptr<aux::channel> internal_connect(ip::tcp::socket* s
++ , ip::tcp::endpoint const& target, boost::system::error_code& ec);
++
++ route find_udp_socket(asio::ip::udp::socket const& socket
++ , ip::udp::endpoint const& ep);
++
++ route const& get_outgoing_route(ip::address ip) const
++ { return m_outgoing_route.find(ip)->second; }
++
++ route const& get_incoming_route(ip::address ip) const
++ { return m_incoming_route.find(ip)->second; }
++
++ int get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const;
++ std::vector<ip::address> const& get_ips() const { return m_ips; }
++
++ sim::simulation& sim() { return m_sim; }
++
++ using executor_type = io_executor;
++ executor_type get_executor() { return executor_type(*this); }
++
++ private:
++
++ sim::simulation& m_sim;
++ std::vector<ip::address> m_ips;
++
++ // these are determined by the configuration. They may include NATs and
++ // DSL modems (queues)
++ std::map<ip::address, route> m_outgoing_route;
++ std::map<ip::address, route> m_incoming_route;
++
++ bool m_stopped = false;
++ };
++
++ template <typename Handler, typename Allocator>
++ void io_executor::dispatch(Handler handler, Allocator const& a) const
++ { m_ctx->dispatch_impl(std::move(handler), a); }
++
++ template <typename Handler, typename Allocator>
++ void io_executor::post(Handler handler, Allocator const& a) const
++ { m_ctx->post_impl(std::move(handler), a); }
++
++ template <typename Handler, typename Allocator>
++ void io_executor::defer(Handler handler, Allocator const& a) const
++ { m_ctx->defer_impl(std::move(handler), a); }
++
++ template <typename Protocol>
++ io_executor
++ socket_base<Protocol>::get_executor()
++ { return io_executor(m_io_service); }
++
++ template <typename Protocol>
++ route socket_base<Protocol>::get_incoming_route()
++ {
++ route ret = m_io_service.get_incoming_route(m_bound_to.address());
++ assert(m_forwarder);
++ ret.append(std::static_pointer_cast<sim::sink>(m_forwarder));
++ return ret;
++ }
++
++ template <typename Protocol>
++ route socket_base<Protocol>::get_outgoing_route()
++ {
++ return route(m_io_service.get_outgoing_route(m_bound_to.address()));
++ }
++
++ } // asio
++
++ // user supplied configuration of the network to simulate
++ struct SIMULATOR_DECL configuration
++ {
++ virtual ~configuration() {}
++
++ // build the network
++ virtual void build(simulation& sim) = 0;
++
++ // return the hops on the network packets from src to dst need to traverse
++ virtual route channel_route(asio::ip::address src
++ , asio::ip::address dst) = 0;
++
++ // return the hops an incoming packet to ep need to traverse before
++ // reaching the socket (for instance a NAT)
++ virtual route incoming_route(asio::ip::address ip) = 0;
++
++ // return the hops an outgoing packet from ep need to traverse before
++ // reaching the network (for instance a DSL modem)
++ virtual route outgoing_route(asio::ip::address ip) = 0;
++
++ // return the path MTU between the two IP addresses
++ // For TCP sockets, this will be called once when the connection is
++ // established. For UDP sockets it's called for every burst of packets
++ // that are sent
++ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
++
++ // called for every hostname lookup made by the client. ``reqyestor`` is
++ // the node performing the lookup, ``hostname`` is the name being looked
++ // up. Resolve the name into addresses and fill in ``result`` or set
++ // ``ec`` if the hostname is not found or some other error occurs. The
++ // return value is the latency of the lookup. The client's callback won't
++ // be called until after waiting this long.
++ virtual chrono::high_resolution_clock::duration hostname_lookup(
++ asio::ip::address const& requestor
++ , std::string hostname
++ , std::vector<asio::ip::address>& result
++ , boost::system::error_code& ec) = 0;
++
++ virtual void clear() = 0;
++ };
++
++ struct SIMULATOR_DECL default_config : configuration
++ {
++ default_config() : m_sim(nullptr) {}
++
++ void build(simulation& sim) override;
++ route channel_route(asio::ip::address src, asio::ip::address dst) override;
++ route incoming_route(asio::ip::address ip) override;
++ route outgoing_route(asio::ip::address ip) override;
++ int path_mtu(asio::ip::address ip1, asio::ip::address ip2) override;
++ chrono::high_resolution_clock::duration hostname_lookup(
++ asio::ip::address const& requestor
++ , std::string hostname
++ , std::vector<asio::ip::address>& result
++ , boost::system::error_code& ec) override;
++
++ void clear() override;
++ protected:
++ std::shared_ptr<queue> m_network;
++ std::map<asio::ip::address, std::shared_ptr<queue>> m_incoming;
++ std::map<asio::ip::address, std::shared_ptr<queue>> m_outgoing;
++ simulation* m_sim;
++ };
++
++ namespace aux
++ {
++ /* the channel can be in the following states:
++ 1. handshake-1 - the initiating socket has sent SYN
++ 2. handshake-2 - the accepting connection has sent SYN+ACK
++ 3. handshake-3 - the initiating connection has received the SYN+ACK and
++ considers the connection open, but the 3rd handshake
++ message is still in flight.
++ 4. connected - the accepting side has received the 3rd handshake
++ packet and considers it open
++
++ Whenever a connection attempt is made to a listening socket, as long as
++ there is still space in the incoming socket queue, the accepting side
++ will always respond immediately and complete the handshake, then wait
++ until the user calls async_accept (which in this case would complete
++ immediately).
++ */
++ struct SIMULATOR_DECL channel
++ {
++ channel() {}
++ // index 0 is the incoming route to the socket that initiated the connection.
++ // index 1 may be empty while the connection is half-open
++ route hops[2];
++
++ // the actual endpoint of each end of the channel
++ asio::ip::tcp::endpoint ep[2];
++
++ // observable endpoint of each side of the channel. This is not how you
++ // see yourself, just the other end
++ asio::ip::tcp::endpoint visible_ep[2];
++
++ // the number of bytes sent from respective direction
++ // this is used to simulate the TCP sequence number, so it deliberately
++ // is meant to wrap at 32 bits
++ std::uint32_t bytes_sent[2];
++
++ int remote_idx(asio::ip::tcp::endpoint const& self) const;
++ int self_idx(asio::ip::tcp::endpoint const& self) const;
++ };
++
++ } // aux
++
++ void SIMULATOR_DECL dump_network_graph(simulation const& s, const std::string& filename);
++}
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif // SIMULATOR_HPP_INCLUDED
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/sink.hpp
+@@ -0,0 +1,47 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SINK_HPP_INCLUDED
++#define SINK_HPP_INCLUDED
++
++#include "simulator/config.hpp"
++#include <string>
++
++namespace sim {
++
++namespace aux {
++ struct packet;
++}
++
++ // this is an interface for somthing that can accept incoming packets,
++ // such as queues, sockets, NATs and TCP congestion windows
++ struct SIMULATOR_DECL sink
++ {
++ virtual void incoming_packet(aux::packet p) = 0;
++
++ // used for visualization
++ virtual std::string label() const = 0;
++
++ virtual std::string attributes() const { return "shape=box"; }
++ virtual ~sink() = default;
++ };
++
++} // sim
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/sink_forwarder.hpp
+@@ -0,0 +1,43 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SINK_FORWARDER_HPP_INCLUDED
++#define SINK_FORWARDER_HPP_INCLUDED
++
++#include "simulator/config.hpp"
++#include "simulator/sink.hpp"
++
++namespace sim { namespace aux {
++
++ struct packet;
++
++ struct SIMULATOR_DECL sink_forwarder final : sink
++ {
++ sink_forwarder(sink* dst);
++ void incoming_packet(packet p) override;
++ std::string label() const override;
++ void reset(sink* s = nullptr);
++
++ private:
++ sink* m_dst;
++ };
++
++}} // sim
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/socks_server.hpp
+@@ -0,0 +1,202 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SOCKS_SERVER_HPP_INCLUDED
++#define SOCKS_SERVER_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++
++#ifdef __GNUC__
++#pragma GCC diagnostic push
++#if __GNUC__ >= 9
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++#endif
++
++#include <boost/bimap.hpp>
++
++#ifdef __GNUC__
++#pragma GCC diagnostic pop
++#endif
++
++#ifdef _MSC_VER
++#pragma warning(push)
++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
++#pragma warning( disable : 4251)
++#endif
++
++namespace sim
++{
++
++enum socks_flag
++{
++ // when this flag is set, the proxy will close the client connection
++ // immediately after sending the response to a UDP ASSOCIATE command
++ disconnect_udp_associate = 1,
++
++ // when this flag is set, the reponse to UDP ASSOCIATE will contain an empty
++ // hostname, rather than the relay IP address
++ udp_associate_respond_empty_hostname = 2
++};
++
++struct SIMULATOR_DECL socks_connection : std::enable_shared_from_this<socks_connection>
++{
++ socks_connection(asio::io_context& ios, int version, std::array<int, 3>& cmd_counts
++ , std::uint32_t flags, int& bind_port);
++
++ asio::ip::tcp::socket& socket() { return m_client_connection; }
++
++ void start();
++
++private:
++
++ void on_handshake1(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_handshake2(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_handshake3(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_request1(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_request2(boost::system::error_code const& ec, size_t bytes_transferred);
++
++ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
++ , bool close);
++ void close_connection();
++
++ int format_response(asio::ip::address const& addr, int port, int response);
++ int format_hostname_response(char const* hostname, int port, int response);
++
++ void on_connected(boost::system::error_code const& ec);
++ void on_request_domain_name(boost::system::error_code const& ec, size_t bytes_transferred);
++ void on_request_domain_lookup(boost::system::error_code const& ec
++ , const asio::ip::tcp::resolver::results_type ips);
++
++ void open_forward_connection(asio::ip::tcp::endpoint const& target);
++ void bind_connection(asio::ip::tcp::endpoint const& target);
++ void start_accept(boost::system::error_code const& ec);
++
++ void udp_associate(asio::ip::tcp::endpoint const& target);
++ void on_read_udp(boost::system::error_code const& ec, std::size_t bytes_transferred);
++ void wait_for_eof(boost::system::error_code const& ec, std::size_t bytes_transferred);
++
++ void on_server_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred);
++ void on_server_forward(boost::system::error_code const& ec
++ , size_t bytes_transferred);
++
++ void on_client_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred);
++ void on_client_forward(boost::system::error_code const& ec
++ , size_t bytes_transferred);
++
++ char const* command() const;
++
++ int& m_bind_port;
++
++ asio::io_context& m_ios;
++
++ asio::ip::udp::resolver m_udp_resolver;
++
++ asio::ip::tcp::resolver m_resolver;
++
++ boost::bimap<asio::ip::address, std::string> m_name_mapping;
++
++ // this is the SOCKS client connection, i.e. the client connecting to us and
++ // being forwarded
++ asio::ip::tcp::socket m_client_connection;
++
++ // this is the connection to the server the socks client is being forwarded
++ // to
++ asio::ip::tcp::socket m_server_connection;
++ asio::ip::tcp::acceptor m_bind_socket;
++
++ asio::ip::udp::socket m_udp_associate;
++ asio::ip::udp::endpoint m_udp_associate_ep;
++ asio::ip::udp::endpoint m_udp_from;
++
++ std::array<char, 1500> m_udp_buffer;
++
++ // receive buffer for data going out, i.e. client -> proxy (us) -> server
++ char m_out_buffer[65536];
++ // buffer size
++ int m_num_out_bytes;
++
++ // receive buffer for data coming in, i.e. server -> proxy (us) -> client
++ char m_in_buffer[65536];
++ // buffer size
++ int m_num_in_bytes;
++
++ // set to true when shutting down
++ bool m_close = false;
++
++ // the SOCKS protocol version (4 or 5)
++ const int m_version;
++
++ int m_command;
++
++ std::array<int, 3>& m_cmd_counts;
++
++ std::uint32_t const m_flags;
++};
++
++// This is a very simple socks4 and 5 server that only supports a single
++// concurrent connection
++struct SIMULATOR_DECL socks_server
++{
++ socks_server(asio::io_context& ios, unsigned short listen_port
++ , int version = 5, std::uint32_t flags = 0);
++
++ void stop();
++
++ void bind_start_port(int const port) { m_bind_port = port; }
++
++ // return the number of CONNECT, BIND and UDP_ASSOCIATE commands the proxy
++ // has received
++ std::array<int, 3> cmd_counts() const
++ { return m_cmd_counts; }
++
++private:
++
++ void on_accept(boost::system::error_code const& ec);
++
++ asio::io_context& m_ios;
++
++ asio::ip::tcp::acceptor m_listen_socket;
++
++ std::shared_ptr<socks_connection> m_conn;
++
++ asio::ip::tcp::endpoint m_ep;
++
++ int m_bind_port = 2048;
++
++ // set to true when shutting down
++ bool m_close = false;
++
++ // the SOCKS protocol version (4 or 5)
++ const int m_version;
++
++ std::array<int, 3> m_cmd_counts;
++
++ std::uint32_t const m_flags;
++};
++
++}
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/ssl.hpp
+@@ -0,0 +1,44 @@
++/*
++
++Copyright (c) 2026, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef SIMULATOR_SSL_HPP_INCLUDED
++#define SIMULATOR_SSL_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++
++#include "simulator/push_warnings.hpp"
++#include <boost/asio/ssl.hpp>
++#include "simulator/pop_warnings.hpp"
++
++namespace sim {
++namespace asio {
++
++namespace ssl
++{
++ using boost::asio::ssl::context;
++ using boost::asio::ssl::stream_base;
++ using boost::asio::ssl::verify_context;
++
++ template <typename Stream>
++ using stream = boost::asio::ssl::stream<Stream>;
++} // ssl
++
++} // asio
++} // sim
++
++#endif
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/utils.hpp
+@@ -0,0 +1,47 @@
++/*
++
++Copyright (c) 2016, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#ifndef UTILS_HPP_INCLUDED
++#define UTILS_HPP_INCLUDED
++
++#include "simulator/simulator.hpp"
++
++namespace sim
++{
++
++// shortcut for creating a timer with a timeout and action
++struct timer
++{
++ timer(simulation& sim, chrono::high_resolution_clock::duration timeout
++ , aux::function<void(boost::system::error_code const&)>&& f)
++ : m_ios(sim, asio::ip::address_v4())
++ , m_timer(m_ios)
++ {
++ m_timer.expires_after(timeout);
++ m_timer.async_wait(std::move(f));
++ }
++
++private:
++ sim::asio::io_context m_ios;
++ sim::asio::high_resolution_timer m_timer;
++};
++
++} // sim
++
++#endif
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/acceptor.cpp
+@@ -0,0 +1,379 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++
++#include <functional>
++#include <boost/beast/core/bind_handler.hpp>
++
++#include <cinttypes>
++
++using boost::beast::bind_handler;
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++namespace sim {
++namespace asio {
++namespace ip {
++
++ tcp::acceptor::acceptor(io_context& ios)
++ : socket(ios)
++ , m_queue_size_limit(-1)
++ {}
++
++ tcp::acceptor::acceptor(acceptor&&) = default;
++
++ tcp::acceptor::~acceptor()
++ {
++ boost::system::error_code ec;
++ close(ec);
++ }
++
++ void tcp::acceptor::listen(int qs)
++ {
++ boost::system::error_code ec;
++ listen(qs, ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void tcp::acceptor::listen(int qs, boost::system::error_code& ec)
++ {
++ if (qs == -1) qs = 20;
++
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return;
++ }
++ if (m_bound_to == ip::tcp::endpoint())
++ {
++ ec = error::invalid_argument;
++ return;
++ }
++
++ m_queue_size_limit = qs;
++ ec.clear();
++ }
++
++ void tcp::acceptor::close(boost::system::error_code& ec)
++ {
++ m_queue_size_limit = -1;
++ cancel(ec);
++ socket::close(ec);
++ }
++
++ void tcp::acceptor::close()
++ {
++ if (m_accept_handler)
++ {
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ }
++
++ void tcp::acceptor::cancel(boost::system::error_code& ec)
++ {
++ ec.clear();
++ if (m_accept_handler)
++ {
++ try
++ {
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = error::no_memory;
++ }
++ catch (std::exception const&)
++ {
++ ec = error::no_memory;
++ }
++ }
++ if (m_accept_handler2)
++ {
++ try
++ {
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = error::no_memory;
++ }
++ catch (std::exception const&)
++ {
++ ec = error::no_memory;
++ }
++ }
++ }
++
++ void tcp::acceptor::cancel()
++ {
++ boost::system::error_code ec;
++ cancel(ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void tcp::acceptor::async_accept(ip::tcp::socket& peer
++ , aux::function<void(boost::system::error_code const&)> h)
++ {
++ // TODO: assert that the io_context we use is the same as the one peer use
++ if (peer.is_open())
++ {
++ boost::system::error_code ec;
++ peer.close(ec);
++ }
++
++ if (m_accept_handler)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ m_accept_handler = std::move(h);
++ m_accept_into = &peer;
++ m_remote_endpoint = nullptr;
++
++ check_accept_queue();
++ }
++
++ void tcp::acceptor::async_accept(ip::tcp::socket& peer
++ , ip::tcp::endpoint& peer_endpoint
++ , aux::function<void(boost::system::error_code const&)> h)
++ {
++ if (peer.is_open())
++ {
++ boost::system::error_code ec;
++ peer.close(ec);
++ }
++
++ if (m_accept_handler)
++ {
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ m_accept_handler = std::move(h);
++ m_accept_into = &peer;
++ m_remote_endpoint = &peer_endpoint;
++
++ check_accept_queue();
++ }
++
++ void tcp::acceptor::async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h)
++ {
++ m_remote_endpoint = nullptr;
++ if (m_accept_handler)
++ {
++ m_accept_into = nullptr;
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ m_accept_into = nullptr;
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ m_new_socket.emplace(m_io_service);
++ m_accept_handler2 = std::move(h);
++ m_accept_into = &*m_new_socket;
++
++ check_accept_queue();
++ }
++
++ void tcp::acceptor::do_check_accept_queue(boost::system::error_code const& ec)
++ {
++ if (ec) return;
++ check_accept_queue();
++ }
++
++ void tcp::acceptor::incoming_packet(aux::packet p)
++ {
++ switch (p.type)
++ {
++ case aux::packet::type_t::syn:
++ m_incoming_conns.push_back(p.channel);
++ check_accept_queue();
++ return;
++ case aux::packet::type_t::error:
++ assert(false); // something is not wired up correctly
++ if (m_accept_handler)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ return;
++ default:
++ // if this happens, it implies that an incoming connection sent
++ // payload before receiving a syn_ack. Alternatively that the
++ // acceptor sent the syn_ack but still left the last-hop in the
++ // incoming route to point to this socket, instead of the
++ // accepted-into socket
++ assert(false);
++ return;
++ }
++ }
++
++ void tcp::acceptor::check_accept_queue()
++ {
++ if (!is_open())
++ {
++ // if the acceptor socket is closed. Any potential socket in the queue
++ // should be closed too.
++ for (auto const& incoming : m_incoming_conns)
++ {
++ aux::packet p;
++ p.from = asio::ip::udp::endpoint(
++ m_bound_to.address(), m_bound_to.port());
++ p.type = aux::packet::type_t::error;
++ p.ec = boost::system::error_code(error::connection_reset);
++ p.overhead = 28;
++ p.hops = incoming->hops[0];
++
++ forward_packet(std::move(p));
++ }
++ m_incoming_conns.clear();
++
++ if (m_accept_handler)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
++ , boost::system::error_code(error::operation_aborted)));
++ }
++ if (m_accept_handler2)
++ {
++ m_accept_into = nullptr;
++ m_remote_endpoint = nullptr;
++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
++ h(boost::system::error_code(error::operation_aborted)
++ , ip::tcp::socket(m_io_service));
++ });
++ }
++ }
++
++ // if the user is not waiting for an incoming connection, there's no point
++ // in checking the queue
++ if (!m_accept_handler && !m_accept_handler2) return;
++
++ if (m_incoming_conns.empty()) return;
++
++ std::shared_ptr<aux::channel> c = std::move(m_incoming_conns.front());
++ m_incoming_conns.erase(m_incoming_conns.begin());
++
++ // this was initiated at least one 3-way handshake ago.
++ // we can pick it up and consider it connected
++ if (m_remote_endpoint) *m_remote_endpoint = c->ep[0];
++ m_remote_endpoint = nullptr;
++
++ boost::system::error_code ec;
++ // if the acceptor socket is closed. Any potential socket in the queue
++ m_accept_into->internal_connect(m_bound_to, c, ec);
++
++ // notify the other end
++ aux::packet p;
++ p.from = asio::ip::udp::endpoint(m_bound_to.address(), m_bound_to.port());
++ if (ec)
++ {
++ c->hops[1] = route();
++ p.type = aux::packet::type_t::error;
++ p.ec = ec;
++ }
++ else
++ {
++ // TODO: extend pcap logging to include SYN+ACK packets
++ p.type = aux::packet::type_t::syn_ack;
++ }
++ p.channel = c;
++ p.overhead = 28;
++ p.hops = p.channel->hops[0];
++
++ forward_packet(std::move(p));
++
++ try
++ {
++ if (m_accept_handler)
++ {
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr), ec));
++ }
++ else if (m_accept_handler2)
++ {
++ post(m_io_service, bind_handler(std::exchange(m_accept_handler2, nullptr)
++ , ec, std::move(*m_accept_into)));
++ }
++ }
++ catch (...)
++ {
++ m_new_socket.reset();
++ m_accept_into = nullptr;
++ throw;
++ }
++ m_new_socket.reset();
++ m_accept_into = nullptr;
++ }
++
++ bool tcp::acceptor::internal_is_listening()
++ {
++ return m_queue_size_limit > 0;
++ }
++}
++}
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/default_config.cpp
+@@ -0,0 +1,106 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/queue.hpp"
++#include <memory>
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++using sim::asio::ip::address_v4;
++using sim::asio::ip::address_v6;
++using sim::asio::ip::address;
++using sim::chrono::milliseconds;
++using sim::chrono::duration_cast;
++
++namespace sim {
++
++ void default_config::build(simulation& sim)
++ {
++ // 0 bandwidth and 0 queue means infinite. The network itself only adds
++ // 50 ms latency
++ m_network = std::make_shared<queue>(std::ref(sim.get_io_context())
++ , 0, duration_cast<duration>(milliseconds(30)), 0, "network");
++ m_sim = ∼
++ }
++
++ void default_config::clear()
++ {
++ m_network.reset();
++ m_outgoing.clear();
++ m_incoming.clear();
++ }
++
++ route default_config::channel_route(
++ asio::ip::address /* src */
++ , asio::ip::address /* dst */)
++ {
++ return route().append(m_network);
++ }
++
++ route default_config::incoming_route(asio::ip::address ip)
++ {
++ // incoming download rate is 800kB/s with a 200 kB queue
++ // and 1 ms forwarding delay
++ auto it = m_incoming.find(ip);
++ if (it != m_incoming.end()) return route().append(it->second);
++ it = m_incoming.insert(it, std::make_pair(ip, std::make_shared<queue>(
++ std::ref(m_sim->get_io_context()), 800 * 1000
++ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem in")));
++ return route().append(it->second);
++ }
++
++ int default_config::path_mtu(
++ asio::ip::address /* ip1 */
++ , asio::ip::address /* ip2 */)
++ {
++ return 1475;
++ }
++
++ // return the hops an outgoing packet from ep need to traverse before
++ // reaching the network (for instance a DSL modem)
++ route default_config::outgoing_route(asio::ip::address ip)
++ {
++ // outgoing upload rate is 200kB/s with a 200 kB queue
++ // and 1 ms forwarding delay
++ auto it = m_outgoing.find(ip);
++ if (it != m_outgoing.end()) return route().append(it->second);
++ it = m_outgoing.insert(it, std::make_pair(ip, std::make_shared<queue>(
++ std::ref(m_sim->get_io_context()), 200 * 1000
++ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem out")));
++ return route().append(it->second);
++ }
++
++ duration default_config::hostname_lookup(
++ asio::ip::address const& /* requestor */
++ , std::string hostname
++ , std::vector<asio::ip::address>& result
++ , boost::system::error_code& ec)
++ {
++ if (hostname == "localhost")
++ {
++ result = { asio::ip::make_address_v6("::1")
++ , asio::ip::make_address_v4("127.0.0.1") };
++ return duration_cast<duration>(chrono::microseconds(1));
++ }
++
++ ec = boost::system::error_code(asio::error::host_not_found);
++ return duration_cast<duration>(chrono::milliseconds(100));
++ }
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/high_resolution_clock.cpp
+@@ -0,0 +1,51 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++
++#include <functional>
++
++#include "simulator/push_warnings.hpp"
++#include <boost/system/error_code.hpp>
++#include "simulator/pop_warnings.hpp"
++
++namespace sim { namespace chrono {
++ namespace {
++
++ // this is the global simulation timer
++ high_resolution_clock::time_point g_simulation_time;
++ }
++
++ high_resolution_clock::time_point high_resolution_clock::now()
++ {
++ return g_simulation_time;
++ }
++
++ void high_resolution_clock::fast_forward(high_resolution_clock::duration d)
++ {
++ g_simulation_time += d;
++ }
++
++ void reset_clock()
++ {
++ g_simulation_time = high_resolution_clock::time_point{};
++ }
++
++} // chrono
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/high_resolution_timer.cpp
+@@ -0,0 +1,141 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/handler_allocator.hpp"
++
++#include <functional>
++#include <boost/system/error_code.hpp>
++
++namespace sim
++{
++
++ namespace asio {
++
++ high_resolution_timer::high_resolution_timer(io_context& ioc)
++ : m_expiration_time(time_type())
++ , m_io_service(&ioc)
++ , m_expired(true)
++ {
++ }
++
++ high_resolution_timer::high_resolution_timer(io_context& ioc,
++ const time_type& expiry_time)
++ : m_expiration_time(time_type())
++ , m_io_service(&ioc)
++ , m_expired(true)
++ {
++ expires_at(expiry_time);
++ }
++
++ high_resolution_timer::high_resolution_timer(io_context& ioc,
++ const duration_type& expiry_time)
++ : m_expiration_time(time_type())
++ , m_io_service(&ioc)
++ , m_expired(true)
++ {
++ expires_after(expiry_time);
++ }
++
++ high_resolution_timer::~high_resolution_timer()
++ {
++ cancel();
++ }
++
++ std::size_t high_resolution_timer::cancel()
++ {
++ if (m_expired) return 0;
++ m_expired = true;
++ m_io_service->remove_timer(this);
++ if (!m_handler) return 0;
++ fire(boost::asio::error::operation_aborted);
++ return 1;
++ }
++
++ std::size_t high_resolution_timer::cancel_one()
++ {
++ // TODO: support multiple handlers
++ return cancel();
++ }
++
++ high_resolution_timer::time_type high_resolution_timer::expiry() const
++ { return m_expiration_time; }
++
++ std::size_t high_resolution_timer::expires_at(high_resolution_timer::time_type const& expiry_time)
++ {
++ std::size_t ret = cancel();
++ m_expiration_time = expiry_time;
++ m_expired = false;
++ m_io_service->add_timer(this);
++ return ret;
++ }
++
++ std::size_t high_resolution_timer::expires_after(const duration_type& expiry_time)
++ {
++ std::size_t ret = cancel();
++ m_expiration_time = chrono::high_resolution_clock::now() + expiry_time;
++ m_expired = false;
++ m_io_service->add_timer(this);
++ return ret;
++ }
++
++ void high_resolution_timer::wait()
++ {
++ assert(false && "can't use synchcronous calls in simulator");
++ boost::system::error_code ec;
++ wait(ec);
++ }
++
++ void high_resolution_timer::wait(boost::system::error_code&)
++ {
++ assert(false && "can't use synchcronous calls in simulator");
++ time_type now = chrono::high_resolution_clock::now();
++ if (now >= m_expiration_time) return;
++ chrono::high_resolution_clock::fast_forward(m_expiration_time - now);
++ }
++
++ void high_resolution_timer::async_wait(aux::function<void(boost::system::error_code const&)> handler)
++ {
++ // TODO: support multiple handlers
++ assert(!m_handler);
++ m_handler = std::move(handler);
++ if (m_expired)
++ {
++ fire(boost::system::error_code());
++ return;
++ }
++ }
++
++ void high_resolution_timer::fire(boost::system::error_code ec)
++ {
++ m_expired = true;
++ if (!m_handler) return;
++ auto h = std::move(m_handler);
++ m_handler = nullptr;
++ post(*m_io_service, make_malloc(std::bind(std::move(h), ec)));
++ }
++
++ high_resolution_timer::executor_type high_resolution_timer::get_executor()
++ {
++ return (*m_io_service).get_executor();
++ }
++
++ } // asio
++
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/http_proxy.cpp
+@@ -0,0 +1,362 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/http_proxy.hpp"
++#include "simulator/http_server.hpp" // for helper functions
++
++#include <functional>
++#include <cstdio> // for printf
++
++using namespace sim::asio;
++using namespace sim::asio::ip;
++using namespace std::placeholders;
++
++using boost::system::error_code;
++
++namespace sim
++{
++ using namespace aux;
++
++ http_proxy::http_proxy(io_context& ios, unsigned short const listen_port)
++ : m_resolver(ios)
++ , m_listen_socket(ios)
++ , m_client_connection(ios)
++ , m_server_connection(ios)
++ , m_writing_to_server(false)
++ , m_num_client_in_bytes(0)
++ , m_num_server_out_bytes(0)
++ , m_num_in_bytes(0)
++ , m_close(false)
++ {
++ address local_ip = ios.get_ips().front();
++ if (local_ip.is_v4())
++ {
++ m_listen_socket.open(tcp::v4());
++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
++ }
++ else
++ {
++ m_listen_socket.open(tcp::v6());
++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
++ }
++ m_listen_socket.listen();
++
++ m_listen_socket.async_accept(m_client_connection, m_ep
++ , std::bind(&http_proxy::on_accept, this, _1));
++ }
++
++ void http_proxy::on_accept(error_code const& ec)
++ {
++ if (ec == asio::error::operation_aborted)
++ return;
++
++ if (ec)
++ {
++ std::printf("http_proxy::on_accept: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ std::printf("http_proxy accepted connection from: %s : %d\n",
++ m_ep.address().to_string().c_str(), m_ep.port());
++
++ // read http request
++ m_client_connection.async_read_some(asio::buffer(
++ &m_client_in_buffer[0], sizeof(m_client_in_buffer))
++ , std::bind(&http_proxy::on_read_request, this, _1, _2));
++ }
++
++ void http_proxy::on_read_request(error_code const& ec, size_t bytes_transferred) try
++ {
++ if (ec)
++ {
++ std::printf("http_proxy::on_read_request: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_num_client_in_bytes += int(bytes_transferred);
++
++ // scan for end of HTTP request
++ int req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
++ while (req_len >= 0)
++ {
++ // parse request from [0, eor), connect to target server and forward
++ // the request.
++ http_request const req = parse_request(m_client_in_buffer, req_len);
++ forward_request(req);
++
++ // pop this request from the receive buffer
++ memmove(m_client_in_buffer, m_client_in_buffer + req_len
++ , m_num_client_in_bytes - req_len);
++ m_num_client_in_bytes -= req_len;
++
++ // is there another request in the buffer?
++ req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
++ }
++
++ // read more from the client
++ m_client_connection.async_read_some(asio::buffer(
++ &m_client_in_buffer[m_num_client_in_bytes]
++ , sizeof(m_client_in_buffer) - m_num_client_in_bytes)
++ , std::bind(&http_proxy::on_read_request, this, _1, _2));
++ }
++ catch (std::runtime_error& e)
++ {
++ std::printf("http_proxy::on_read_request() failed: %s\n"
++ , e.what());
++ close_connection();
++ }
++
++ void http_proxy::forward_request(http_request const& req)
++ {
++ std::string out_request;
++ out_request = req.method;
++ out_request += ' ';
++ if (req.req.compare(0, 7, "http://") != 0)
++ {
++ std::printf("http_proxy::forward_request: expected full URL in request, got: %s\n"
++ , req.req.c_str());
++ throw std::runtime_error("invalid request");
++ }
++
++ std::string::size_type const path_start = req.req.find_first_of('/', 7);
++ if (path_start == std::string::npos) out_request += '/';
++ else out_request.append(req.req, path_start, std::string::npos);
++ out_request += " HTTP/1.1\r\n";
++
++ std::string::size_type const host_end = req.req.substr(0, path_start).find_last_of(':');
++
++ std::string host = req.req.substr(7, (host_end != std::string::npos && host_end > 7)
++ ? host_end - 7 : path_start - 7);
++
++ // if the hostname is an IPv6 address, strip the brackets around it to
++ // make it parse correctly
++ if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
++ host = host.substr(1, host.size() - 2);
++
++ int const port = host_end == std::string::npos || host_end <= 7 ? 80
++ : atoi(req.req.substr(host_end + 1, path_start).c_str());
++ assert(port >= 0 && port < 0xffff);
++
++ bool found_host = false;
++ for (auto const& h : req.headers)
++ {
++ if (h.first == "host") found_host = true;
++
++ out_request += h.first;
++ out_request += ": ";
++ out_request += h.second;
++ out_request += "\r\n";
++ }
++ if (!found_host)
++ {
++ out_request += "host: ";
++ out_request += host;
++ out_request += "\r\n";
++ }
++ out_request += "\r\n";
++
++ if (m_num_server_out_bytes + out_request.size() > sizeof(m_server_out_buffer))
++ {
++ std::printf("http_proxy: Too many queued server requests: %d bytes\n"
++ , int(m_num_server_out_bytes + out_request.size()));
++ throw std::runtime_error("pipeline too deep");
++ }
++ memmove(&m_server_out_buffer[m_num_server_out_bytes]
++ , out_request.data(), out_request.size());
++ m_num_server_out_bytes += int(out_request.size());
++
++ if (!m_server_connection.is_open())
++ {
++ boost::system::error_code err;
++ tcp::endpoint target(make_address(host.c_str(), err)
++ , static_cast<unsigned short>(port));
++ if (err)
++ {
++ char port_str[10];
++ std::snprintf(port_str, sizeof(port_str), "%d", port);
++ m_resolver.async_resolve(host, port_str
++ , std::bind(&http_proxy::on_domain_lookup, this, _1, _2));
++ return;
++ }
++ open_forward_connection(target);
++ return;
++ }
++
++ // TODO: make sure we're connecting/connected to the same (host, port)
++ // that this request is for. Don't support multiple servers
++
++ write_server_send_buffer();
++ }
++
++ void http_proxy::on_domain_lookup(boost::system::error_code const& ec
++ , const asio::ip::tcp::resolver::results_type ips)
++ {
++ if (ec || ips.empty())
++ {
++ if (ec)
++ {
++ std::printf("http_proxy::on_domain_lookup: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ }
++ else
++ {
++ std::printf("http_proxy::on_request_domain_lookup: empty response\n");
++ }
++ error(503, "Resource Temporarily Unavailable");
++ return;
++ }
++ open_forward_connection(ips.front().endpoint());
++ }
++
++ void http_proxy::open_forward_connection(const asio::ip::tcp::endpoint& target)
++ {
++ m_server_connection.open(target.protocol());
++
++ std::printf("http_proxy: async_connect: %s:%d\n"
++ , target.address().to_string().c_str(), target.port());
++ m_server_connection.async_connect(target
++ , std::bind(&http_proxy::on_connected, this, _1));
++ }
++
++ void http_proxy::error(int code, char const* message)
++ {
++ std::string send_buffer = send_response(code, message);
++ memcpy(m_in_buffer, send_buffer.data(), send_buffer.size());
++ asio::async_write(m_client_connection, asio::buffer(
++ &m_in_buffer[0], send_buffer.size())
++ , std::bind(&http_proxy::close_connection, this));
++ }
++
++ void http_proxy::on_connected(boost::system::error_code const& ec)
++ {
++ if (ec)
++ {
++ std::printf("http_proxy::on_connected() connection failed: %s\n", ec.message().c_str());
++ m_server_connection.close();
++ error(503, "Service Temporarily Unavailable");
++ return;
++ }
++
++ std::printf("http_proxy: connected\n");
++
++ write_server_send_buffer();
++
++ m_server_connection.async_read_some(
++ asio::buffer(m_in_buffer, sizeof(m_in_buffer))
++ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
++ }
++
++ void http_proxy::write_server_send_buffer()
++ {
++ if (m_writing_to_server) return;
++ m_writing_to_server = true;
++ m_server_connection.async_write_some(asio::buffer(
++ &m_server_out_buffer[0], m_num_server_out_bytes)
++ , std::bind(&http_proxy::on_server_write, this, _1, _2));
++ }
++
++ void http_proxy::on_server_write(error_code const& ec, size_t bytes_transferred)
++ {
++ m_writing_to_server = false;
++ if (ec)
++ {
++ std::printf("http_proxy::on_server_write: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ memmove(&m_server_out_buffer[0], &m_server_out_buffer[bytes_transferred]
++ , m_num_server_out_bytes - bytes_transferred);
++ m_num_server_out_bytes -= int(bytes_transferred);
++
++ if (m_num_server_out_bytes > 0)
++ write_server_send_buffer();
++ }
++
++ // we received some data from the server, forward it to the server
++ void http_proxy::on_server_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred)
++ {
++ if (ec)
++ {
++ std::printf("http_proxy: error reading from server: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
++ , std::bind(&http_proxy::on_server_forward, this, _1, _2));
++ }
++
++ void http_proxy::on_server_forward(error_code const& ec
++ , size_t)
++ {
++ if (ec)
++ {
++ std::printf("http_proxy: error writing to client: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_server_connection.async_read_some(
++ sim::asio::buffer(m_in_buffer, sizeof(m_in_buffer))
++ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
++ }
++
++ void http_proxy::stop()
++ {
++ m_close = true;
++ m_listen_socket.close();
++ }
++
++ void http_proxy::close_connection()
++ {
++ m_num_client_in_bytes = 0;
++ m_num_server_out_bytes = 0;
++ m_num_in_bytes = 0;
++
++ error_code err;
++ m_client_connection.close(err);
++ if (err)
++ {
++ std::printf("http_proxy::close: failed to close client connection (%d) %s\n"
++ , err.value(), err.message().c_str());
++ }
++ m_server_connection.close(err);
++ if (err)
++ {
++ std::printf("http_proxy::close: failed to close server connection (%d) %s\n"
++ , err.value(), err.message().c_str());
++ }
++
++ if (m_close) return;
++
++ // now we can accept another connection
++ m_listen_socket.async_accept(m_client_connection, m_ep
++ , std::bind(&http_proxy::on_accept, this, _1));
++ }
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/http_server.cpp
+@@ -0,0 +1,425 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/http_server.hpp"
++
++#include <functional>
++#include <cstdio> // for printf
++
++using namespace sim::asio;
++using namespace sim::asio::ip;
++using namespace std::placeholders;
++
++using boost::system::error_code;
++
++namespace sim
++{
++ using namespace aux;
++
++ namespace {
++ char const* find(char const* hay, int const hsize
++ , char const* needle, int const nsize)
++ {
++ for (int i = 0; i < hsize - nsize + 1; ++i)
++ {
++ if (memcmp(hay + i, needle, nsize) == 0) return hay + i;
++ }
++ return nullptr;
++ }
++ }
++
++ std::string trim(std::string s)
++ {
++ if (s.empty()) return s;
++
++ int start = 0;
++ int end = int(s.size());
++ while (strchr(" \r\n\t", s[start]) != NULL && start < end)
++ {
++ ++start;
++ }
++
++ while (strchr(" \r\n\t", s[end-1]) != NULL && end > start)
++ {
++ --end;
++ }
++ return s.substr(start, end - start);
++ }
++
++ std::string lower_case(std::string s)
++ {
++ std::string ret;
++ std::transform(s.begin(), s.end(), std::back_inserter(ret)
++ , [](char c) { return static_cast<char>(tolower(c)); } );
++ return ret;
++ }
++
++ std::string normalize(const std::string& s)
++ {
++ std::vector<std::string> elements;
++ char const* start = s.c_str();
++ if (*start == '/') ++start;
++ char const* slash = strchr(start, '/');
++ while (slash != NULL)
++ {
++ std::string element(start, slash - start);
++ if (element != "..")
++ {
++ elements.push_back(element);
++ } else if (!elements.empty())
++ {
++ elements.erase(elements.end()-1);
++ }
++ start = slash + 1;
++ slash = strchr(start, '/');
++ }
++ elements.push_back(start);
++
++ std::string ret;
++ for (auto const& e : elements)
++ {
++ ret += '/';
++ ret += e;
++ }
++
++ return ret;
++ }
++
++ // TODO: extra_header should be a std::vector
++ std::string send_response(int code, char const* status_message
++ , int len, char const** extra_header)
++ {
++ std::string ret = "HTTP/1.1 " + std::to_string(code) + " " + status_message + "\r\n";
++
++ ret += "content-length: " + std::to_string(len) + "\r\n";
++
++ if (extra_header)
++ {
++ ret += extra_header[0];
++ ret += extra_header[1];
++ ret += extra_header[2];
++ ret += extra_header[3];
++ }
++ ret += "\r\n";
++
++ return ret;
++ }
++
++ http_server::http_server(io_context& ios, unsigned short listen_port, int flags)
++ : m_ios(ios)
++ , m_listen_socket(ios)
++ , m_connection(ios)
++ , m_bytes_used(0)
++ , m_close(false)
++ , m_flags(flags)
++ {
++ address local_ip = ios.get_ips().front();
++ if (local_ip.is_v4())
++ {
++ m_listen_socket.open(tcp::v4());
++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
++ }
++ else
++ {
++ m_listen_socket.open(tcp::v6());
++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
++ }
++ m_listen_socket.listen();
++
++ m_listen_socket.async_accept(m_connection, m_ep
++ , std::bind(&http_server::on_accept, this, _1));
++ }
++
++ void http_server::on_accept(error_code const& ec)
++ {
++ if (ec)
++ {
++ std::printf("http_server::on_accept: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ ++m_accepted_connections;
++
++ std::printf("http_server accepted connection from: %s : %d\n",
++ m_ep.address().to_string().c_str(), m_ep.port());
++
++ read();
++ }
++
++ void http_server::register_handler(std::string const& path, handler_t h)
++ {
++ m_handlers[path] = std::move(h);
++ }
++
++ void http_server::register_content(std::string const& path
++ , std::int64_t const size, generator_t gen)
++ {
++ m_handlers[path] = [gen,size](std::string, std::string, std::map<std::string, std::string>& hdr)
++ {
++ std::int64_t start = 0;
++ std::int64_t end = size;
++
++ auto it = hdr.find("range");
++ bool const range_req = it != hdr.end();
++ if (range_req)
++ {
++ std::string range = it->second;
++ // skip "bytes "
++ range = range.substr(range.find_first_of('=') + 1);
++ start = std::stoll(range.substr(0, range.find('-')));
++ end = std::stoll(range.substr(range.find_first_of('-') + 1)) + 1;
++ }
++
++ std::string header = "Content-Range: bytes " + std::to_string(start)
++ + "-" + std::to_string(end-1) + "/" + std::to_string(end-start) + "\r\n";
++ char const* extra_headers[4] = { header.c_str(), "", "", ""};
++
++ return sim::send_response(range_req ? 206 : 200
++ , range_req ? "Partial Content" : "OK"
++ , int(end - start), range_req ? extra_headers : nullptr)
++ + gen(start, end - start);
++ };
++ }
++
++ void http_server::register_redirect(std::string const& path, std::string const& target)
++ {
++ m_handlers[path] = [target](std::string, std::string, std::map<std::string, std::string>&)
++ {
++ std::string header = "Location: " + target + "\r\n";
++ char const* extra_headers[4] = { header.c_str(), "", "", ""};
++ return sim::send_response(301, "Moved Permanently", 0, extra_headers);
++ };
++ }
++
++ void http_server::register_stall_handler(std::string const& path){
++ m_stall_handlers.insert(path);
++ }
++
++ void http_server::read()
++ {
++ if (m_bytes_used >= int(m_recv_buffer.size()) / 2)
++ {
++ m_recv_buffer.resize((std::max)(500, m_bytes_used * 2));
++ }
++ assert(int(m_recv_buffer.size()) > m_bytes_used);
++ m_connection.async_read_some(asio::buffer(&m_recv_buffer[m_bytes_used]
++ , m_recv_buffer.size() - m_bytes_used)
++ , std::bind(&http_server::on_read, this, _1, _2));
++ }
++
++ http_request parse_request(char const* start, int len)
++ {
++ http_request ret;
++
++ char const* const end_of_request = start + len;
++ char const* const space = find(start, len, " ", 1);
++ if (space == nullptr)
++ {
++ std::printf("http_server: failed to parse request:\n%s\n"
++ , std::string(start, len).c_str());
++ throw std::runtime_error("parse failed");
++ }
++
++ char const* const space2 = find(space + 1
++ , int(len - (space - start + 1)), " ", 1);
++ if (space2 == nullptr)
++ {
++ std::printf("http_server: failed to parse request:\n%s\n"
++ , std::string(start, len).c_str());
++ throw std::runtime_error("parse failed");
++ }
++ ret.method.assign(start, space);
++ ret.req.assign(space+1, space2);
++ if (ret.method != "CONNECT") {
++ ret.path.assign(normalize(ret.req.substr(0, ret.req.find_first_of('?'))));
++ } else {
++ ret.path.assign(ret.req);
++ }
++ std::printf("parse_request: %s %s [%s]\n"
++ , ret.method.c_str(), ret.path.c_str(), ret.req.c_str());
++
++ char const* header = find(space2, int(len - (space2 - start)), "\r\n", 2);
++ while (header != end_of_request - 4)
++ {
++ if (header == nullptr)
++ {
++ std::printf("http_server: failed to parse request:\n%s\n"
++ , std::string(start, len).c_str());
++ throw std::runtime_error("parse failed");
++ }
++ char const* const next = find(header + 2
++ , int(len - (header + 2 - start)), "\r\n", 2);
++ char const* const value = static_cast<char const*>(memchr(header, ':', len - (header - start)));
++ if (value == nullptr || next == nullptr || value > next)
++ {
++ std::printf("http_server: failed to parse request:\n%s\n"
++ , std::string(start, len).c_str());
++ throw std::runtime_error("parse failed");
++ }
++
++ ret.headers[lower_case(trim(std::string(header, value)))]
++ = trim(std::string(value+1, next));
++
++ header = next;
++ }
++ return ret;
++ }
++
++ int find_request_len(char const* buf, int const len)
++ {
++ char const* end_of_request = find(buf, len, "\r\n\r\n", 4);
++ if (end_of_request == nullptr) return -1;
++ return int(end_of_request - buf + 4);
++ }
++
++ void http_server::on_read(error_code const& ec, size_t bytes_transferred) try
++ {
++ if (ec)
++ {
++ std::printf("http_server::on_read: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_bytes_used += int(bytes_transferred);
++
++ int const req_len = find_request_len(m_recv_buffer.data(), m_bytes_used);
++ if (req_len < 0)
++ {
++ read();
++ return;
++ }
++
++ http_request req = parse_request(m_recv_buffer.data(), req_len);
++
++ m_recv_buffer.erase(m_recv_buffer.begin(), m_recv_buffer.begin() + req_len);
++ m_bytes_used -= req_len;
++
++ auto it = m_handlers.find(req.path);
++ if (it == m_handlers.end())
++ {
++ if (m_stall_handlers.find(req.path) != m_stall_handlers.end())
++ {
++ return;
++ }
++ // no handler found, 404
++ m_send_buffer = send_response(404, "Not Found");
++ }
++ else
++ {
++ m_send_buffer = it->second(req.method, req.req, req.headers);
++ }
++
++ // decide whether to close the connection after this response, and signal
++ // it to the client appropriately.
++ bool close;
++ if (m_flags & http_1_0)
++ {
++ // an HTTP/1.0 server closes after every response and does not use the
++ // Connection header (that is an HTTP/1.1 mechanism). Downgrade the
++ // status line so the client detects this from the protocol version.
++ close = true;
++ auto const ver = m_send_buffer.find("HTTP/1.1");
++ if (ver != std::string::npos)
++ m_send_buffer.replace(ver, 8, "HTTP/1.0");
++ }
++ else
++ {
++ // close if the client asked us to, or if this server is not
++ // configured for keep-alive. When we do, advertise it with a
++ // "Connection: close" response header so the client knows not to
++ // reuse the socket (rather than discovering it via a failed write).
++ close = lower_case(req.headers["connection"]) == "close"
++ || !(m_flags & keep_alive);
++ if (close)
++ {
++ auto const status_end = m_send_buffer.find("\r\n");
++ if (status_end != std::string::npos)
++ {
++ assert(m_send_buffer.find("Connection:") == std::string::npos);
++ m_send_buffer.insert(status_end + 2, "Connection: close\r\n");
++ }
++ }
++ }
++
++ async_write(m_connection, asio::buffer(m_send_buffer.data()
++ , m_send_buffer.size()), std::bind(&http_server::on_write
++ , this, _1, _2, close));
++ }
++ catch (std::exception& e)
++ {
++ std::printf("http_server::on_read() failed: %s\n"
++ , e.what());
++ close_connection();
++ }
++
++ void http_server::on_write(error_code const& ec
++ , size_t /* bytes_transferred */
++ , bool close)
++ {
++ if (ec)
++ {
++ std::printf("http_server::on_write: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ if (!close)
++ {
++ // try to read another request out of the buffer
++ post(m_ios, std::bind(&http_server::on_read, this, error_code(), 0));
++ }
++ else
++ {
++ close_connection();
++ }
++ }
++
++ void http_server::stop()
++ {
++ m_close = true;
++ m_listen_socket.close();
++ }
++
++ void http_server::close_connection()
++ {
++ m_recv_buffer.clear();
++ m_bytes_used = 0;
++
++ error_code err;
++ m_connection.close(err);
++ if (err)
++ {
++ std::printf("http_server::close: failed to close connection (%d) %s\n"
++ , err.value(), err.message().c_str());
++ return;
++ }
++
++ if (m_close) return;
++
++ // now we can accept another connection
++ m_listen_socket.async_accept(m_connection, m_ep
++ , std::bind(&http_server::on_accept, this, _1));
++ }
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/io_service.cpp
+@@ -0,0 +1,272 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++
++#include <boost/make_shared.hpp>
++#include <boost/system/error_code.hpp>
++
++namespace sim { namespace asio {
++
++ io_context::io_context(sim::simulation& sim)
++ : io_context(sim, std::vector<asio::ip::address>())
++ {}
++
++ io_context::io_context(sim::simulation& sim, asio::ip::address const& ip)
++ : io_context(sim, std::vector<asio::ip::address>{ip})
++ {}
++
++ io_context::io_context(sim::simulation& sim, std::vector<asio::ip::address> const& ips)
++ : m_sim(sim)
++ , m_ips(ips)
++ , m_stopped(false)
++ {
++ for (auto const& ip : m_ips)
++ {
++ m_outgoing_route[ip] = m_sim.config().outgoing_route(ip);
++ m_incoming_route[ip] = m_sim.config().incoming_route(ip);
++ }
++ m_sim.add_io_service(this);
++ }
++
++ io_context::~io_context()
++ {
++ m_sim.remove_io_service(this);
++ }
++
++ // this constructor is never meant to be called (hence the assert). It only
++ // exists to satisfy interfaces that require a default-like constructor. The
++ // null reference is deliberate, so suppress the warning about it.
++#if defined __clang__
++#pragma clang diagnostic push
++#pragma clang diagnostic ignored "-Wnull-dereference"
++#elif defined __GNUC__
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-Wnull-dereference"
++#endif
++ io_context::io_context(std::size_t)
++ : m_sim(*reinterpret_cast<sim::simulation*>(0))
++ {
++ assert(false);
++ }
++#if defined __clang__
++#pragma clang diagnostic pop
++#elif defined __GNUC__
++#pragma GCC diagnostic pop
++#endif
++
++ int io_context::get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const
++ {
++ // TODO: it would be nice to actually traverse the virtual network nodes
++ // and ask for their MTU instead
++ assert(std::count(m_ips.begin(), m_ips.end(), source) > 0 && "source address must be a local address to this node/io_context");
++ return m_sim.config().path_mtu(source, dest);
++ }
++
++ void io_context::stop()
++ {
++ // TODO: cancel all outstanding handler associated with this io_context
++ m_stopped = true;
++ }
++
++ bool io_context::stopped() const
++ {
++ return m_stopped;
++ }
++
++ void io_context::restart()
++ {
++ m_stopped = false;
++ }
++
++ std::size_t io_context::run()
++ {
++ assert(false);
++ return 0;
++ }
++
++ std::size_t io_context::run(boost::system::error_code&)
++ {
++ assert(false);
++ return 0;
++ }
++
++ std::size_t io_context::poll()
++ {
++ assert(false);
++ return 0;
++ }
++
++ std::size_t io_context::poll(boost::system::error_code&)
++ {
++ assert(false);
++ return 0;
++ }
++
++ std::size_t io_context::poll_one()
++ {
++ assert(false);
++ return 0;
++ }
++
++ std::size_t io_context::poll_one(boost::system::error_code&)
++ {
++ assert(false);
++ return 0;
++ }
++
++ // private interface
++
++ void io_context::add_timer(high_resolution_timer* t)
++ {
++ m_sim.add_timer(t);
++ }
++
++ void io_context::remove_timer(high_resolution_timer* t)
++ {
++ m_sim.remove_timer(t);
++ }
++
++ boost::asio::io_context& io_context::get_internal_service()
++ { return m_sim.get_internal_service(); }
++
++ ip::tcp::endpoint io_context::bind_socket(ip::tcp::socket* socket
++ , ip::tcp::endpoint ep, boost::system::error_code& ec)
++ {
++ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
++ if (ep.address() == ip::address_v4::any())
++ {
++ auto it = std::find_if(m_ips.begin(), m_ips.end()
++ , [](ip::address const& ip) { return ip.is_v4(); } );
++ if (it == m_ips.end())
++ {
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::tcp::endpoint();
++ }
++ // TODO: pick the first local endpoint for now. In the future we may
++ // want have a bias toward
++ ep.address(*it);
++ }
++ else if (ep.address() == ip::address_v6::any())
++ {
++ auto it = std::find_if(m_ips.begin(), m_ips.end()
++ , [](ip::address const& ip) { return ip.is_v6(); } );
++ if (it == m_ips.end())
++ {
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::tcp::endpoint();
++ }
++ // TODO: pick the first local endpoint for now. In the future we may
++ // want have a bias toward
++ ep.address(*it);
++ }
++ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
++ {
++ // you can only bind to the IP assigned to this node.
++ // TODO: support loopback
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::tcp::endpoint();
++ }
++
++ return m_sim.bind_socket(socket, ep, ec);
++ }
++
++ void io_context::unbind_socket(ip::tcp::socket* socket
++ , const ip::tcp::endpoint& ep)
++ {
++ m_sim.unbind_socket(socket, ep);
++ }
++
++ void io_context::rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep)
++ {
++ m_sim.rebind_socket(prev, s, ep);
++ }
++
++ ip::udp::endpoint io_context::bind_udp_socket(ip::udp::socket* socket
++ , ip::udp::endpoint ep, boost::system::error_code& ec)
++ {
++ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
++ if (ep.address() == ip::address_v4::any())
++ {
++ auto it = std::find_if(m_ips.begin(), m_ips.end()
++ , [](ip::address const& ip) { return ip.is_v4(); });
++ if (it == m_ips.end())
++ {
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::udp::endpoint();
++ }
++ // TODO: pick the first local endpoint for now. In the future we may
++ // want have a bias toward
++ ep.address(*it);
++ }
++ else if (ep.address() == ip::address_v6::any())
++ {
++ auto it = std::find_if(m_ips.begin(), m_ips.end()
++ , [](ip::address const& ip) { return ip.is_v6(); });
++ if (it == m_ips.end())
++ {
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::udp::endpoint();
++ }
++ // TODO: pick the first local endpoint for now. In the future we may
++ // want have a bias toward
++ ep.address(*it);
++ }
++ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
++ {
++ // you can only bind to the IP assigned to this node.
++ // TODO: support loopback
++ ec.assign(boost::system::errc::address_not_available
++ , boost::system::generic_category());
++ return ip::udp::endpoint();
++ }
++
++ return m_sim.bind_udp_socket(socket, ep, ec);
++ }
++
++ void io_context::unbind_udp_socket(ip::udp::socket* socket
++ , const ip::udp::endpoint& ep)
++ {
++ m_sim.unbind_udp_socket(socket, ep);
++ }
++
++ void io_context::rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep)
++ {
++ m_sim.rebind_udp_socket(socket, ep);
++ }
++
++ std::shared_ptr<aux::channel> io_context::internal_connect(ip::tcp::socket* s
++ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
++ {
++ return m_sim.internal_connect(s, target, ec);
++ }
++
++ route io_context::find_udp_socket(asio::ip::udp::socket const& socket
++ , ip::udp::endpoint const& ep)
++ {
++ return m_sim.find_udp_socket(socket, ep);
++ }
++
++} // asio
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/nat.cpp
+@@ -0,0 +1,47 @@
++/*
++
++Copyright (c) 2018, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/nat.hpp"
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++#include <string>
++
++namespace sim {
++
++ nat::nat(asio::ip::address external_addr) : m_external_addr(external_addr) {}
++
++ void nat::incoming_packet(aux::packet p)
++ {
++ // unconditionally replacing the "from" address is fine because of our
++ // simplified network model where the two paths of a connection are set up
++ // independently, and we can set up the nat hop only on the outgoing path
++ p.from.address(m_external_addr);
++ if (p.channel) {
++ p.channel->visible_ep[0].address(m_external_addr);
++ }
++ forward_packet(std::move(p));
++ }
++
++ // used for visualization
++ std::string nat::label() const
++ {
++ return std::string("NAT [") + m_external_addr.to_string() + "]";
++ }
++
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/pcap.cpp
+@@ -0,0 +1,204 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/pcap.hpp"
++#include "simulator/chrono.hpp"
++#include "simulator/packet.hpp"
++
++using sim::chrono::duration_cast;
++using sim::chrono::seconds;
++
++using sim::asio::ip::address_v4;
++using sim::asio::ip::tcp;
++using sim::asio::ip::udp;
++
++namespace sim { namespace aux {
++
++namespace {
++
++ template <typename T, typename cond = typename std::enable_if<std::is_pod<T>::value>::type>
++ void write(std::fstream& o, T const& value)
++ { o.write(reinterpret_cast<char const*>(&value), sizeof(value)); }
++
++ // documented here:
++ // http://www.tcpdump.org/linktypes.html
++ std::uint32_t const LINKTYPE_RAW = 101;
++
++ struct ip_header
++ {
++ std::uint8_t version_len;
++ std::uint8_t dscp;
++ std::uint16_t length;
++ std::uint16_t identification;
++ std::uint16_t fragment;
++ std::uint8_t ttl;
++ std::uint8_t protocol;
++ std::uint16_t checksum;
++ std::uint32_t source_ip;
++ std::uint32_t destination_ip;
++ };
++
++ struct udp_header
++ {
++ std::uint16_t src_port;
++ std::uint16_t dst_port;
++ std::uint16_t length;
++ std::uint16_t checksum;
++ };
++
++ struct tcp_header
++ {
++ std::uint16_t src_port;
++ std::uint16_t dst_port;
++ std::uint32_t seq_nr;
++ std::uint32_t ack_nr;
++ std::uint8_t offset;
++ std::uint8_t flags;
++ std::uint16_t window_size;
++ std::uint16_t checksum;
++ std::uint16_t urgent;
++ };
++}
++
++ pcap::pcap(char const* filename)
++ : m_file(filename, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary)
++ {
++ // file format documented here:
++ // https://wiki.wireshark.org/Development/LibpcapFileFormat
++ // write pcap file header
++ write(m_file, std::uint32_t(0xa1b2c3d4)); // magic number
++ write(m_file, std::uint16_t(2)); // versopm major
++ write(m_file, std::uint16_t(4)); // versopm minor
++ write(m_file, std::int32_t(0)); // thiszone
++ write(m_file, std::uint32_t(0)); // sigfigs
++ write(m_file, std::uint32_t(0xffff)); // snaplen
++ write(m_file, LINKTYPE_RAW); // network
++ }
++
++ void write_ip_header(std::fstream& file, int const size, int const protocol
++ , address_v4 const source, address_v4 const dest)
++ {
++ ip_header const header = {
++ (4 << 4) | 5, // version_len
++ 0, // dscp
++ htons(std::uint16_t(size)), // length
++ 0, // identification
++ 0, // fragment
++ 200, // ttl
++ std::uint8_t(protocol), // protocol
++ 0, // checksum
++ htonl(std::uint32_t(source.to_uint())), // source ip
++ htonl(std::uint32_t(dest.to_uint())) // destination ip
++ };
++
++ write(file, header);
++ }
++
++ void write_udp_header(std::fstream& file, int const size, int const src_port
++ , int const dst_port)
++ {
++ assert(src_port != 0);
++ assert(dst_port != 0);
++ udp_header const header = {
++ htons(std::uint16_t(src_port)), // source port
++ htons(std::uint16_t(dst_port)), // destination port
++ htons(std::uint16_t(sizeof(udp_header) + size)), // length
++ 0 // checksum
++ };
++
++ write(file, header);
++ }
++
++ void write_tcp_header(std::fstream& file, int const src_port
++ , int const dst_port, std::uint32_t const seq_nr)
++ {
++ assert(src_port != 0);
++ assert(dst_port != 0);
++ tcp_header const header = {
++ htons(std::uint16_t(src_port)), // source port
++ htons(std::uint16_t(dst_port)), // destination port
++ htonl(seq_nr), // sequence number
++ std::uint32_t(0), // acknowledgement number
++ std::uint8_t(5 << 4), // header size (data offset)
++ std::uint8_t(0), // flags
++ htons(std::uint16_t(65535)), // window size
++ std::uint16_t(0), // checksum
++ std::uint16_t(0) // urgent offset
++ };
++
++ write(file, header);
++ }
++
++ void pcap::log_tcp(packet const& p, tcp::endpoint const src
++ , tcp::endpoint const dst)
++ {
++ // synthesize IP/TCP header and write packet
++ auto const now = chrono::high_resolution_clock::now();
++
++ // just an arbitrary posix time used as starting point
++ std::uint32_t const sim_start_time = 441794304;
++ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
++ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
++
++ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(tcp_header) + p.buffer.size());
++
++ write(m_file, sim_start_time + secs);
++ write(m_file, usecs);
++ write(m_file, packet_size);
++ write(m_file, packet_size);
++
++ // 6 is the protocol number for TCP
++ write_ip_header(m_file, packet_size, 6
++ , src.address().to_v4(), dst.address().to_v4());
++
++ // TODO: if the packet has error set with asio::error::eof
++ // set the FIN flag
++ write_tcp_header(m_file, p.from.port(), dst.port(), p.byte_counter);
++
++ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
++ }
++
++ void pcap::log_udp(packet const& p, udp::endpoint const src
++ , udp::endpoint const dst)
++ {
++ // synthesize IP/UDP header and write packet
++ auto const now = chrono::high_resolution_clock::now();
++
++ // just an arbitrary posix time used as starting point
++ std::uint32_t const sim_start_time = 441794304;
++ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
++ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
++
++ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(udp_header) + p.buffer.size());
++
++ write(m_file, sim_start_time + secs);
++ write(m_file, usecs);
++ write(m_file, packet_size);
++ write(m_file, packet_size);
++
++ // 17 is the protocol number for UDP
++ write_ip_header(m_file, packet_size, 17
++ , src.address().to_v4(), dst.address().to_v4());
++
++ write_udp_header(m_file, static_cast<int>(p.buffer.size()), p.from.port(), static_cast<int>(dst.port()));
++
++ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
++ }
++
++}}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/queue.cpp
+@@ -0,0 +1,142 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/queue.hpp"
++#include "simulator/handler_allocator.hpp"
++#include <functional>
++#include <cstdio> // for printf
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++namespace sim
++{
++ using namespace aux;
++
++ queue::queue(asio::io_context& ios
++ , int bandwidth
++ , chrono::high_resolution_clock::duration propagation_delay
++ , int max_queue_size
++ , std::string name)
++ : m_max_queue_size(max_queue_size)
++ , m_forwarding_latency(propagation_delay)
++ , m_bandwidth(bandwidth)
++ , m_queue_size(0)
++ , m_node_name(name)
++ , m_forward_timer(ios)
++ , m_last_forward(chrono::high_resolution_clock::now())
++ {}
++
++ std::string queue::label() const
++ {
++ char ret[400];
++ int p = std::snprintf(ret, sizeof(ret), "%s\n", m_node_name.c_str());
++
++ if (m_bandwidth != 0)
++ {
++ p += std::snprintf(ret + p, sizeof(ret) - p, "rate: %d kB/s\n"
++ , m_bandwidth / 1000);
++ }
++
++ if (m_queue_size != 0)
++ {
++ p += std::snprintf(ret + p, sizeof(ret) - p, "queue: %d kB\n"
++ , m_queue_size / 1000);
++ }
++
++ if (m_forwarding_latency.count() != 0)
++ {
++ p += std::snprintf(ret + p, sizeof(ret) - p, "latency: %d ms\n"
++ , int(chrono::duration_cast<chrono::milliseconds>(m_forwarding_latency).count()));
++ }
++
++ return ret;
++ }
++
++ void queue::incoming_packet(aux::packet p)
++ {
++ const int packet_size = int(p.buffer.size() + p.overhead);
++
++ // tail-drop
++ if (p.ok_to_drop()
++ && m_max_queue_size > 0
++ && m_queue_size + packet_size > m_max_queue_size)
++ {
++ // if any hop on the network drops a packet, it has to return it to the
++ // sender.
++ auto drop_fun = std::move(p.drop_fun);
++ if (drop_fun) drop_fun(std::move(p));
++ return;
++ }
++
++ time_point const now = chrono::high_resolution_clock::now();
++
++ m_queue.emplace_back(now + m_forwarding_latency, std::move(p));
++ m_queue_size += packet_size;
++ if (m_queue.size() > 1) return;
++
++ begin_send_next_packet();
++ }
++
++ void queue::begin_send_next_packet()
++ {
++ time_point now = chrono::high_resolution_clock::now();
++
++ if (m_queue.front().ts > now)
++ {
++ m_forward_timer.expires_at(m_queue.front().ts);
++ m_forward_timer.async_wait(make_malloc(std::bind(&queue::begin_send_next_packet
++ , this)));
++ return;
++ }
++
++ m_last_forward = now;
++ if (m_bandwidth == 0)
++ {
++ post(m_forward_timer.get_executor(), make_malloc(std::bind(&queue::next_packet_sent
++ , this)));
++ return;
++ }
++ const double nanoseconds_per_byte = 1000000000.0
++ / double(m_bandwidth);
++
++ aux::packet const& p = m_queue.front().pkt;
++ const int packet_size = int(p.buffer.size() + p.overhead);
++
++ m_last_forward += chrono::duration_cast<duration>(chrono::nanoseconds(
++ boost::int64_t(nanoseconds_per_byte * packet_size)));
++
++ m_forward_timer.expires_at(m_last_forward);
++ m_forward_timer.async_wait(make_malloc(std::bind(&queue::next_packet_sent
++ , this)));
++ }
++
++ void queue::next_packet_sent()
++ {
++ aux::packet p = std::move(m_queue.front().pkt);
++ m_queue.erase(m_queue.begin());
++ const int packet_size = int(p.buffer.size() + p.overhead);
++ m_queue_size -= packet_size;
++
++ forward_packet(std::move(p));
++
++ if (m_queue.size())
++ begin_send_next_packet();
++ }
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/resolver.cpp
+@@ -0,0 +1,143 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/handler_allocator.hpp"
++#include <functional>
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++using namespace std::placeholders;
++
++namespace sim {
++namespace asio {
++namespace ip {
++
++ template<typename Protocol>
++ basic_resolver<Protocol>::basic_resolver(io_context& ios)
++ : m_ios(&ios)
++ , m_timer(ios)
++ {}
++
++ template<typename Protocol>
++ basic_resolver<Protocol>::basic_resolver(basic_resolver<Protocol>&&) noexcept = default;
++
++ template<typename Protocol>
++ basic_resolver<Protocol>& basic_resolver<Protocol>::operator=(basic_resolver<Protocol>&&) noexcept = default;
++
++ template<typename Protocol>
++ void basic_resolver<Protocol>::async_resolve(std::string hostname, char const* service
++ , aux::function<void(boost::system::error_code const&, results_type)> handler)
++ {
++ std::vector<asio::ip::address> result;
++ boost::system::error_code ec;
++
++ const chrono::high_resolution_clock::time_point start_time =
++ m_queue.empty() ? chrono::high_resolution_clock::now() :
++ m_queue.front().completion_time;
++
++ assert(!m_ios->get_ips().empty() && "internal io service objects can only "
++ "be used for timers");
++
++ // if the hostname is an IP address, resolve it immediately
++ asio::ip::address addr = make_address_v4(hostname, ec);
++ if (ec) addr = make_address_v6(hostname, ec);
++ if (!ec)
++ {
++ const chrono::high_resolution_clock::time_point t = chrono::high_resolution_clock::now()
++ + chrono::microseconds(1);
++ results_type ips;
++ int const port = atoi(service);
++ assert(port >= 0 && port <= 0xffff);
++ ips.emplace_back(
++ typename Protocol::endpoint(addr, static_cast<unsigned short>(port))
++ , hostname, service);
++ result_t res{t, ec, std::move(ips), std::move(handler) };
++ m_queue.insert(m_queue.begin(), std::move(res));
++ m_timer.expires_at(m_queue.front().completion_time);
++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
++ return;
++ }
++ ec.clear();
++
++ const chrono::high_resolution_clock::time_point completion_time =
++ start_time
++ + m_ios->sim().config().hostname_lookup(m_ios->get_ips().front(), hostname
++ , result, ec);
++
++ results_type ips;
++
++ int const port = atoi(service);
++ assert(port >= 0 && port <= 0xffff);
++
++ for (auto const& ip : result)
++ {
++ ips.emplace_back(
++ typename Protocol::endpoint(ip, static_cast<unsigned short>(port))
++ , hostname, service);
++ }
++
++ result_t res{ completion_time, ec, std::move(ips), std::move(handler)};
++ m_queue.emplace_back(std::move(res));
++
++ m_timer.expires_at(m_queue.front().completion_time);
++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
++ }
++
++ template<typename Protocol>
++ void basic_resolver<Protocol>::on_lookup(boost::system::error_code const& ec)
++ {
++ if (ec == asio::error::operation_aborted) return;
++
++ if (m_queue.empty()) return;
++
++ typename queue_t::value_type v = std::move(m_queue.front());
++ m_queue.erase(m_queue.begin());
++
++ // once the handler is called, it's possible the last reference keeping
++ // this object (basic_resolver) alive is released and we're deleted. Make
++ // sure to not touch any members after the handler in that case.
++ bool const empty = m_queue.empty();
++ v.handler(v.err, std::move(v.ips));
++ if (empty) return;
++
++ m_timer.expires_at(m_queue.front().completion_time);
++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
++ }
++
++ template<typename Protocol>
++ void basic_resolver<Protocol>::cancel()
++ {
++ queue_t q;
++ m_queue.swap(q);
++ for (auto& r : q)
++ {
++ r.err = asio::error::operation_aborted;
++ post(m_timer.get_executor(), aux::make_malloc(std::bind(std::move(r.handler)
++ , r.err, std::move(r.ips))));
++ }
++ }
++
++ // explicitly instantiate the functions
++ template struct basic_resolver<udp>;
++ template struct basic_resolver<tcp>;
++}
++}
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/simulation.cpp
+@@ -0,0 +1,381 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++#include "simulator/pcap.hpp"
++
++#include <tuple> // for tie
++#include <memory> // for make_shared
++#include <cstdio> // for printf
++#include <iostream>
++#include <stdexcept> // for std::runtime_error
++
++using namespace sim::asio;
++
++namespace sim
++{
++ simulation::simulation(configuration& config)
++ : m_config(config)
++ , m_internal_ios(new asio::io_context(*this))
++ , m_service(1)
++ {
++ sim::chrono::reset_clock();
++ m_config.build(*this);
++ }
++
++ simulation::~simulation()
++ {
++ m_config.clear();
++
++ assert(m_timer_queue.empty());
++ }
++
++ std::size_t simulation::run() try
++ {
++ std::size_t ret = 0;
++ std::size_t last_executed = 0;
++
++ // Detect a runaway loop where events keep firing but simulated time
++ // never advances - typically a timer being repeatedly scheduled at the
++ // current time (a 100% CPU spin that would otherwise hang run()
++ // forever). Legitimate bursts of same-timestamp events are finite, so
++ // a large threshold reliably distinguishes them from an unbounded spin.
++ chrono::high_resolution_clock::time_point prev_time
++ = chrono::high_resolution_clock::now();
++ std::int64_t stalled_iterations = 0;
++ constexpr std::int64_t max_stalled_iterations = 1000;
++
++ do {
++
++ m_service.restart();
++ last_executed = m_service.poll();
++ ret += last_executed;
++
++ chrono::high_resolution_clock::time_point now
++ = chrono::high_resolution_clock::now();
++
++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
++ if (!m_timer_queue.empty()) {
++ asio::high_resolution_timer* next_timer = *m_timer_queue.begin();
++ chrono::high_resolution_clock::fast_forward(next_timer->expiry() - now);
++
++ now = chrono::high_resolution_clock::now();
++
++ while (!m_timer_queue.empty()
++ && (*m_timer_queue.begin())->expiry() <= now) {
++
++ next_timer = *m_timer_queue.begin();
++ m_timer_queue.erase(m_timer_queue.begin());
++ next_timer->fire(boost::system::error_code());
++ ++last_executed;
++ ++ret;
++ }
++ }
++
++ if (last_executed > 0) {
++ if (now == prev_time) {
++ if (++stalled_iterations > max_stalled_iterations) {
++ throw std::runtime_error("libsimulator: simulated time "
++ "has not advanced for too many consecutive iterations "
++ "while events keep firing. The simulation is stuck in a "
++ "busy loop, typically a timer repeatedly scheduled at "
++ "the current time (a 100% CPU spin).");
++ }
++ } else {
++ stalled_iterations = 0;
++ prev_time = now;
++ }
++ }
++
++// std::fprintf(stderr, "run: last_executed: %d stopped: %d timer-queue: %d\n"
++// , int(last_executed), m_stopped, int(m_timer_queue.size()));
++ } while (last_executed > 0 && !m_stopped);
++
++// std::fprintf(stderr, "exiting simulation::run(): last_executed: %d stopped: %d timer-queue: %d ret: %d\n"
++// , int(last_executed), m_stopped, int(m_timer_queue.size()), int(ret));
++ return ret;
++ }
++ catch (...)
++ {
++ // cancel all outstanding timers
++ // we make a copy, since cancelling the timers will mutate m_timer_queue
++ auto queue = m_timer_queue;
++ for (auto& t : queue)
++ t->cancel();
++
++ auto listen_sockets = m_listen_sockets;
++ for (auto& s : listen_sockets)
++ s.second->cancel();
++
++ auto udp_sockets = m_udp_sockets;
++ for (auto& s : udp_sockets)
++ s.second->cancel();
++ m_stopped = true;
++ throw;
++ }
++
++ void simulation::stop() { m_stopped = true; }
++ bool simulation::stopped() const { return m_stopped; }
++ void simulation::restart() { m_stopped = false; }
++
++ void simulation::add_timer(asio::high_resolution_timer* t)
++ {
++ assert(!m_stopped);
++ if (t->expiry() == sim::chrono::high_resolution_clock::now())
++ {
++ std::fprintf(stderr, "WARNING: timer scheduled for current time!\n");
++ }
++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
++ // make sure we get a deterministic ordering of timers with the same
++ // expiration time
++ auto it = std::upper_bound(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
++ m_timer_queue.insert(it, t);
++ }
++
++ void simulation::remove_timer(asio::high_resolution_timer* t)
++ {
++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
++ if (m_timer_queue.empty()) return;
++ timer_queue_t::iterator begin;
++ timer_queue_t::iterator end;
++ std::tie(begin, end) = std::equal_range(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
++ if (begin == end) return;
++ begin = std::find(begin, end, t);
++ if (begin == end) return;
++ m_timer_queue.erase(begin);
++ }
++
++ void simulation::rebind_socket(ip::tcp::socket* prev, ip::tcp::socket* s, ip::tcp::endpoint ep)
++ {
++ auto i = m_listen_sockets.find(ep);
++ assert(i != m_listen_sockets.end());
++ if (i->second != prev) return;
++ i->second = s;
++ }
++
++ ip::tcp::endpoint simulation::bind_socket(ip::tcp::socket* socket
++ , ip::tcp::endpoint ep, boost::system::error_code& ec)
++ {
++ assert(ep.address() != boost::asio::ip::address());
++
++ if (ep.port() < 1024 && ep.port() > 0)
++ {
++ // emulate process not running as root
++ ec = boost::asio::error::access_denied;
++ return ip::tcp::endpoint();
++ }
++
++ if (ep.port() == 0)
++ {
++ // if the socket is being bound to port 0, it means the system picks a
++ // free port. We want to avoid re-using ports, because that may confuse
++ // wireshark when threading together the TCP streams.
++ ep.port(m_next_bind_port++);
++ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
++
++ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
++ while (i != m_listen_sockets.end() && i->first == ep)
++ {
++ ep.port(ep.port() + 1);
++ if (ep.port() > 65530)
++ {
++ ec = boost::asio::error::address_in_use;
++ return ip::tcp::endpoint();
++ }
++ i = m_listen_sockets.lower_bound(ep);
++ }
++ }
++
++ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
++ if (i != m_listen_sockets.end() && i->first == ep)
++ {
++ ec = boost::asio::error::address_in_use;
++ return ip::tcp::endpoint();
++ }
++
++ m_listen_sockets.insert(i, std::make_pair(ep, socket));
++ ec.clear();
++ return ep;
++ }
++
++ void simulation::unbind_socket(ip::tcp::socket* socket
++ , const ip::tcp::endpoint& ep)
++ {
++ listen_socket_iter_t i = m_listen_sockets.find(ep);
++ if (i == m_listen_sockets.end() || i->second != socket) return;
++ m_listen_sockets.erase(i);
++ }
++
++ void simulation::rebind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep)
++ {
++ auto i = m_udp_sockets.find(ep);
++ assert(i != m_udp_sockets.end());
++ i->second = socket;
++ }
++
++ ip::udp::endpoint simulation::bind_udp_socket(ip::udp::socket* socket
++ , ip::udp::endpoint ep, boost::system::error_code& ec)
++ {
++ assert(ep.address() != boost::asio::ip::address());
++
++ if (ep.port() < 1024 && ep.port() > 0)
++ {
++ // emulate process not running as root
++ ec = boost::asio::error::access_denied;
++ return ip::udp::endpoint();
++ }
++
++ if (ep.port() == 0)
++ {
++ // if the socket is being bound to port 0, it means the system picks a
++ // free port.
++
++ ep.port(m_next_bind_port++);
++ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
++ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
++ while (i != m_udp_sockets.end() && i->first == ep)
++ {
++ ep.port(ep.port() + 1);
++ if (ep.port() > 65530)
++ {
++ ec = boost::asio::error::address_in_use;
++ return ip::udp::endpoint();
++ }
++ i = m_udp_sockets.lower_bound(ep);
++ }
++ }
++
++ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
++ if (i != m_udp_sockets.end() && i->first == ep)
++ {
++ ec = boost::asio::error::address_in_use;
++ return ip::udp::endpoint();
++ }
++
++ m_udp_sockets.insert(i, std::make_pair(ep, socket));
++ ec.clear();
++ return ep;
++ }
++
++ void simulation::unbind_udp_socket(ip::udp::socket* socket
++ , const ip::udp::endpoint& ep)
++ {
++ udp_socket_iter_t i = m_udp_sockets.find(ep);
++ if (i == m_udp_sockets.end() || i->second != socket) return;
++ m_udp_sockets.erase(i);
++ }
++
++ std::shared_ptr<aux::channel> simulation::internal_connect(
++ asio::ip::tcp::socket* s
++ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
++ {
++ // find remote socket
++ listen_sockets_t::iterator i = m_listen_sockets.find(target);
++ if (i == m_listen_sockets.end())
++ {
++ ec = boost::system::error_code(error::connection_refused);
++ return std::shared_ptr<aux::channel>();
++ }
++
++ // make sure it's a listening socket
++ ip::tcp::socket* remote = i->second;
++ if (!remote->internal_is_listening())
++ {
++ ec = boost::system::error_code(error::connection_refused);
++ return std::shared_ptr<aux::channel>();
++ }
++
++ // create a channel
++ std::shared_ptr<aux::channel> c = std::make_shared<aux::channel>();
++
++ asio::ip::tcp::endpoint from = s->local_bound_to(ec);
++
++ route network_route = m_config.channel_route(from.address()
++ , target.address());
++ c->hops[0] = remote->get_outgoing_route() + network_route + s->get_incoming_route();
++ c->hops[1] = s->get_outgoing_route() + network_route + remote->get_incoming_route();
++
++ c->ep[0] = s->local_bound_to(ec);
++ c->ep[1] = remote->local_bound_to(ec);
++
++ c->visible_ep[0] = s->local_bound_to(ec);
++ c->visible_ep[1] = remote->local_bound_to(ec);
++
++ aux::packet p;
++ p.type = aux::packet::type_t::syn;
++ p.overhead = 28;
++ p.from = asio::ip::udp::endpoint(from.address(), from.port());
++ p.channel = c;
++ if (ec) return std::shared_ptr<aux::channel>();
++
++ p.hops = c->hops[1];
++
++ forward_packet(std::move(p));
++
++ return c;
++ }
++
++ route simulation::find_udp_socket(asio::ip::udp::socket const& socket
++ , ip::udp::endpoint const& ep)
++ {
++ udp_socket_iter_t i = m_udp_sockets.find(ep);
++ if (i == m_udp_sockets.end())
++ return route();
++
++ ip::udp::endpoint src = socket.local_bound_to();
++ route network_route = m_config.channel_route(src.address(), ep.address());
++
++ // ask the socket for its incoming route
++ network_route.append(i->second->get_incoming_route());
++
++ return network_route;
++ }
++
++ void simulation::add_io_service(asio::io_context* ios)
++ {
++ bool added = m_nodes.insert(ios).second;
++ (void)added;
++ assert(added);
++ }
++
++ void simulation::remove_io_service(asio::io_context* ios)
++ {
++ auto it = m_nodes.find(ios);
++ assert(it != m_nodes.end());
++ m_nodes.erase(it);
++ }
++
++ std::vector<io_context*> simulation::get_all_io_services() const
++ {
++ std::vector<io_context*> ret;
++ ret.reserve(m_nodes.size());
++ std::remove_copy_if(
++ m_nodes.begin(), m_nodes.end(), std::back_inserter(ret)
++ , [](io_context* ios) { return ios->get_ips().empty(); });
++ return ret;
++ }
++
++ void simulation::log_pcap(char const* filename)
++ {
++ std::printf("saving packet capture to: \"%s\"\n", filename);
++ m_pcap = std::unique_ptr<aux::pcap>(new aux::pcap(filename));
++ }
++
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/simulator.cpp
+@@ -0,0 +1,262 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++
++#include <functional>
++#include <unordered_set>
++#include <set>
++#include <cstdio> // for printf
++
++#include "simulator/push_warnings.hpp"
++#include <boost/system/error_code.hpp>
++#include "simulator/pop_warnings.hpp"
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++namespace sim {
++namespace asio {
++namespace ip {
++
++ default_config default_cfg;
++
++} // ip
++} // asio
++
++void forward_packet(aux::packet p)
++{
++ std::shared_ptr<sink> next_hop = p.hops.pop_front();
++ if (!next_hop)
++ {
++ std::fprintf(stderr, "packet lost\n");
++ return;
++ }
++ next_hop->incoming_packet(std::move(p));
++}
++
++namespace
++{
++ // this is a dummy sink for endpoints, wrapping an io_context
++ struct endpoint : sink
++ {
++ endpoint(asio::io_context& ioc)
++ : m_ioc(ioc)
++ {}
++
++ virtual void incoming_packet(aux::packet /* p */) override final { assert(false); }
++
++ virtual std::string label() const override final
++ {
++ std::string ret;
++ for (auto const& ip : m_ioc.get_ips())
++ {
++ ret += ip.to_string();
++ ret += " ";
++ }
++ return ret;
++ }
++
++ virtual std::string attributes() const override final
++ {
++ return "shape=ellipse";
++ }
++
++ private:
++ asio::io_context& m_ioc;
++ };
++}
++
++namespace
++{
++ std::string escape_label(std::string n)
++ {
++ std::string ret;
++ for (auto c : n)
++ {
++ if (c == '\n')
++ {
++ ret += "\\n";
++ continue;
++ }
++ if (c == '\"')
++ {
++ ret += "\\\"";
++ continue;
++ }
++ ret += c;
++ }
++ return ret;
++ }
++}
++
++void dump_network_graph(simulation const& s, const std::string& filename)
++{
++ // all edges (directed).
++ std::set<std::pair<std::shared_ptr<sink>, std::shared_ptr<sink>>> edges;
++
++ // all network nodes
++ std::unordered_set<std::shared_ptr<sink>> nodes;
++
++ // local nodes (subgrapgs)
++ std::vector<std::unordered_set<std::shared_ptr<sink>>> local_nodes;
++
++ const std::vector<asio::io_context*> io_services = s.get_all_io_services();
++
++ for (auto ioc : io_services)
++ {
++ std::shared_ptr<sink> ep = std::make_shared<endpoint>(*ioc);
++ local_nodes.push_back(std::unordered_set<std::shared_ptr<sink>>());
++ local_nodes.back().insert(ep);
++
++ for (auto const& ip : ioc->get_ips())
++ {
++ route in = ioc->get_incoming_route(ip);
++ route out = ioc->get_outgoing_route(ip);
++
++ // this is the outgoing node for this endpoint. This is
++ // how it connects to the network.
++ const std::shared_ptr<sink> egress = out.empty() ? ep : out.last();
++
++ // first add both the incoming and outgoing chains
++ std::shared_ptr<sink> prev;
++ while (!in.empty())
++ {
++ auto node = in.pop_front();
++ local_nodes.back().insert(node);
++ if (prev) edges.insert({prev, node});
++ prev = node;
++ }
++ if (prev) edges.insert({prev, ep});
++
++ prev = ep;
++ while (!out.empty())
++ {
++ auto node = out.pop_front();
++ local_nodes.back().insert(node);
++ edges.insert({prev, node});
++ prev = node;
++ }
++
++ // then connect the endpoint of those chains to the rest of the network.
++ // Since the network may be arbitrarily complex, we actually have to
++ // completely iterate over all other endpoints
++
++ for (auto ios2 : io_services)
++ {
++ for (auto const& ip2 : ios2->get_ips())
++ {
++ route network = s.config().channel_route(
++ ip, ip2);
++
++ std::shared_ptr<sink> last = ios2->get_incoming_route(ip2).next_hop();
++
++ prev = egress;
++ while (!network.empty())
++ {
++ auto node = network.pop_front();
++ nodes.insert(node);
++ edges.insert({prev, node});
++ prev = node;
++ }
++ edges.insert({prev, last});
++ }
++ }
++ }
++ }
++
++ // by now, the nodes and edges should represent the complete graph. Render it
++ // into dot.
++
++ FILE* f = fopen(filename.c_str(), "w+");
++
++ std::fprintf(f, "digraph network {\n"
++ "concentrate=true;\n"
++ "overlap=scale;\n"
++ "splines=true;\n");
++
++ std::fprintf(f, "\n// nodes\n\n");
++
++ for (const auto& n : nodes)
++ {
++ std::string attributes = n->attributes();
++ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"red\"%s%s];\n"
++ , static_cast<void*>(n.get())
++ , escape_label(n->label()).c_str()
++ , attributes.empty() ? "" : ", "
++ , attributes.c_str());
++ }
++
++ std::fprintf(f, "\n// local networks\n\n");
++
++ int idx = 0;
++ for (auto ln : local_nodes)
++ {
++ std::fprintf(f, "subgraph cluster_%d {\n", idx++);
++
++ for (const auto& n : ln)
++ {
++ std::string attributes = n->attributes();
++ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"green\"%s%s];\n"
++ , static_cast<void*>(n.get())
++ , escape_label(n->label()).c_str()
++ , attributes.empty() ? "" : ", "
++ , attributes.c_str());
++ }
++
++ std::fprintf(f, "}\n");
++ }
++
++ std::fprintf(f, "\n// edges\n\n");
++
++ while (!edges.empty())
++ {
++ auto edge = *edges.begin();
++ edges.erase(edges.begin());
++
++ std::fprintf(f, "\"%p\" -> \"%p\"\n"
++ , static_cast<void*>(edge.first.get())
++ , static_cast<void*>(edge.second.get()));
++ }
++
++ std::fprintf(f, "}\n");
++ fclose(f);
++}
++
++namespace aux {
++
++ int channel::remote_idx(const asio::ip::tcp::endpoint& self) const
++ {
++ if (ep[0] == self) return 1;
++ if (ep[1] == self) return 0;
++ assert(false && "invalid socket");
++ return -1;
++ }
++
++ int channel::self_idx(const asio::ip::tcp::endpoint& self) const
++ {
++ if (ep[0] == self) return 0;
++ if (ep[1] == self) return 1;
++ assert(false && "invalid socket");
++ return -1;
++ }
++
++} // aux
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/sink_forwarder.cpp
+@@ -0,0 +1,45 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/sink_forwarder.hpp"
++#include "simulator/packet.hpp"
++
++namespace sim { namespace aux {
++
++ sink_forwarder::sink_forwarder(sink* dst)
++ : m_dst(dst)
++ {}
++
++ void sink_forwarder::incoming_packet(packet p)
++ {
++ if (m_dst == nullptr) return;
++ m_dst->incoming_packet(std::move(p));
++ }
++
++ std::string sink_forwarder::label() const
++ {
++ return m_dst ? m_dst->label() : "";
++ }
++
++ void sink_forwarder::reset(sink* s)
++ {
++ m_dst = s;
++ }
++
++}}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/socks_server.cpp
+@@ -0,0 +1,1033 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/socks_server.hpp"
++
++#include <functional>
++#include <cstdint>
++#include <cinttypes>
++#include <cstdio> // for printf
++
++using namespace sim::asio;
++using namespace sim::asio::ip;
++
++using boost::system::error_code;
++
++namespace sim
++{
++ using namespace aux;
++
++ socks_server::socks_server(io_context& ios, unsigned short listen_port, int version
++ , std::uint32_t const flags)
++ : m_ios(ios)
++ , m_listen_socket(ios)
++ , m_conn(std::make_shared<socks_connection>(m_ios, version, m_cmd_counts, flags, m_bind_port))
++ , m_version(version)
++ , m_flags(flags)
++ {
++ m_cmd_counts.fill(0);
++ address local_ip = ios.get_ips().front();
++ if (local_ip.is_v4())
++ {
++ m_listen_socket.open(tcp::v4());
++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
++ }
++ else
++ {
++ m_listen_socket.open(tcp::v6());
++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
++ }
++ m_listen_socket.listen();
++
++ m_listen_socket.async_accept(m_conn->socket(), m_ep
++ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
++ }
++
++ void socks_server::on_accept(error_code const& ec)
++ {
++ if (ec == asio::error::operation_aborted)
++ return;
++
++ if (ec)
++ {
++ std::printf("socks_server::on_accept: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ return;
++ }
++
++ std::printf("socks_server accepted connection from: %s : %d\n",
++ m_ep.address().to_string().c_str(), m_ep.port());
++
++ m_conn->start();
++
++ // create a new connection to accept into
++ m_conn = std::make_shared<socks_connection>(m_ios, m_version, m_cmd_counts, m_flags, m_bind_port);
++
++ // now we can accept another connection
++ m_listen_socket.async_accept(m_conn->socket(), m_ep
++ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
++ }
++
++ void socks_server::stop()
++ {
++ m_close = true;
++ m_listen_socket.close();
++ }
++
++ socks_connection::socks_connection(asio::io_context& ios
++ , int version, std::array<int, 3>& cmd_counts, std::uint32_t const flags, int& bind_port)
++ : m_bind_port(bind_port)
++ , m_ios(ios)
++ , m_udp_resolver(ios)
++ , m_resolver(m_ios)
++ , m_client_connection(ios)
++ , m_server_connection(m_ios)
++ , m_bind_socket(m_ios)
++ , m_udp_associate(m_ios)
++ , m_num_out_bytes(0)
++ , m_num_in_bytes(0)
++ , m_version(version)
++ , m_command(0)
++ , m_cmd_counts(cmd_counts)
++ , m_flags(flags)
++ {
++ }
++
++ void socks_connection::start()
++ {
++ if (m_version == 4)
++ {
++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 9)
++ , std::bind(&socks_connection::on_request1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
++ } else {
++ // read protocol version and number of auth-methods
++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 2)
++ , std::bind(&socks_connection::on_handshake1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
++ }
++ }
++
++ void socks_connection::on_handshake1(error_code const& ec, size_t bytes_transferred)
++ {
++ if (ec || bytes_transferred != 2)
++ {
++ std::printf("socks_connection::on_handshake1: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ if (m_out_buffer[0] != 4 && m_out_buffer[0] != 5)
++ {
++ std::printf("socks_connection::on_handshake1: unexpected socks protocol version: %d"
++ , int(m_out_buffer[0]));
++ close_connection();
++ return;
++ }
++
++ int num_methods = unsigned(m_out_buffer[1]);
++
++ // read list of auth-methods
++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0],
++ num_methods)
++ , std::bind(&socks_connection::on_handshake2, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_handshake2(error_code const& ec, size_t bytes_transferred)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection::on_handshake2: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ if (std::count(m_out_buffer, m_out_buffer + bytes_transferred, 0) == 0)
++ {
++ std::printf("socks_connection: could not find auth-method 0 (no-auth) in socks handshake\n");
++ close_connection();
++ return;
++ }
++
++ m_in_buffer[0] = 5; // socks version
++ m_in_buffer[1] = 0; // auth-method (no-auth)
++
++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], 2)
++ , std::bind(&socks_connection::on_handshake3, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_handshake3(error_code const& ec, size_t bytes_transferred)
++ {
++ if (ec || bytes_transferred != 2)
++ {
++ std::printf("socks_connection::on_handshake3: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 10)
++ , std::bind(&socks_connection::on_request1, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_request1(error_code const& ec, size_t bytes_transferred)
++ {
++ size_t const expected = m_version == 4 ? 9 : 10;
++ if (ec || bytes_transferred != expected)
++ {
++ std::printf("socks_connection::on_request1: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++// +----+-----+-------+------+----------+----------+
++// |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | Variable | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ int const version = m_out_buffer[0];
++ int const command = m_out_buffer[1];
++ m_command = command;
++ ++m_cmd_counts[command - 1];
++
++ if (version != m_version)
++ {
++ std::printf("socks_connection::on_request1: unexpected socks protocol version: %d expected: %d\n"
++ , int(m_out_buffer[0]), m_version);
++ close_connection();
++ return;
++ }
++
++ if (m_version == 4)
++ {
++ if (command != 1 && command != 2)
++ {
++ std::printf("socks_connection::on_request1: unexpected socks command: %d\n"
++ , command);
++ close_connection();
++ return;
++ }
++
++ std::uint16_t port = m_out_buffer[2] & 0xff;
++ port <<= 8;
++ port |= m_out_buffer[3] & 0xff;
++
++ std::uint32_t addr = m_out_buffer[4] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[5] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[6] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[7] & 0xff;
++
++ if (m_out_buffer[8] != 0)
++ {
++ // in this case, we would have to read one byte at a time until we
++ // get to the null terminator.
++ std::printf("socks_connection::on_request1: username in SOCKS4 mode not supported\n");
++ close_connection();
++ return;
++ }
++ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
++ if (command == 1)
++ {
++ open_forward_connection(target);
++ }
++ else if (command == 2)
++ {
++ bind_connection(target);
++ }
++
++ return;
++ }
++
++ if (command != 1 && command != 2 && command != 3)
++ {
++ std::printf("socks_connection::on_request1: unexpected command: %d\n"
++ , command);
++ close_connection();
++ return;
++ }
++
++ if (m_out_buffer[2] != 0)
++ {
++ std::printf("socks_connection::on_request1: reserved byte is non-zero: %d\n"
++ , int(m_out_buffer[2]));
++ close_connection();
++ return;
++ }
++
++ int atyp = unsigned(m_out_buffer[3]);
++
++ if (atyp != 1 && atyp != 3 && atyp != 4)
++ {
++ std::printf("socks_connection::on_request1: unexpected address type in SOCKS request: %d\n"
++ , atyp);
++ close_connection();
++ return;
++ }
++
++ std::printf("socks_connection: received %s request address type: %d\n"
++ , command == 1 ? "CONNECT"
++ : command == 2 ? "BIND"
++ : "UDP_ASSOCIATE", atyp);
++
++ switch (atyp)
++ {
++ case 1: { // IPv4 address (we have the whole request already)
++
++// +----+-----+-------+------+----------+----------+
++// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | 4 | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ std::uint32_t addr = m_out_buffer[4] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[5] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[6] & 0xff;
++ addr <<= 8;
++ addr |= m_out_buffer[7] & 0xff;
++
++ std::uint16_t port = m_out_buffer[8] & 0xff;
++ port <<= 8;
++ port |= m_out_buffer[9] & 0xff;
++
++ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
++ if (command == 1)
++ {
++ open_forward_connection(target);
++ }
++ else if (command == 2)
++ {
++ bind_connection(target);
++ }
++ else if (command == 3)
++ {
++ if (target.address() == address())
++ {
++ target.address(m_client_connection.remote_endpoint().address());
++ }
++ udp_associate(target);
++ }
++
++ break;
++ }
++ case 3: { // domain name
++
++// +----+-----+-------+------+-----+----------+----------+
++// |VER | CMD | RSV | ATYP | LEN | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+-----+----------+----------+
++// | 1 | 1 | X'00' | 1 | 1 | Variable | 2 |
++// +----+-----+-------+------+-----+----------+----------+
++
++ if (command == 2)
++ {
++ std::printf("ERROR: cannot BIND to hostname address (only IPv4 or IPv6 addresses)\n");
++ close_connection();
++ return;
++ }
++
++ const int len = std::uint8_t(m_out_buffer[4]);
++ // we already read an address of length 4, assuming it was an IPv4
++ // address. Now, with a domain name, one of those bytes was the
++ // length-prefix, but we still read 3 bytes already.
++ const int additional_bytes = len - 3;
++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[10], additional_bytes)
++ , std::bind(&socks_connection::on_request_domain_name
++ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
++ break;
++ }
++ case 4: // IPv6 address
++
++// +----+-----+-------+------+----------+----------+
++// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | 16 | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ std::printf("ERROR: unsupported address type %d\n", atyp);
++ close_connection();
++ }
++ }
++
++ void socks_connection::on_request_domain_name(error_code const& ec, size_t bytes_transferred)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection::on_request_domain_name(%s): (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ int const buffer_size = int(10 + bytes_transferred);
++
++ std::uint16_t port = m_out_buffer[buffer_size - 2] & 0xff;
++ port <<= 8;
++ port |= m_out_buffer[buffer_size - 1] & 0xff;
++
++ std::string hostname(&m_out_buffer[5], std::uint8_t(m_out_buffer[4]));
++ std::printf("socks_connection::on_request_domain_name(%s): hostname: %s port: %d\n"
++ , command(), hostname.c_str(), port);
++
++ char port_str[10];
++ std::snprintf(port_str, sizeof(port_str), "%d", port);
++ m_resolver.async_resolve(hostname, port_str
++ , std::bind(&socks_connection::on_request_domain_lookup
++ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_request_domain_lookup(boost::system::error_code const& ec
++ , asio::ip::tcp::resolver::results_type const ips)
++ {
++ if (ec || ips.empty())
++ {
++ if (ec)
++ {
++ std::printf("socks_connection::on_request_domain_lookup(%s): (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ }
++ else
++ {
++ std::printf("socks_connection::on_request_domain_lookup(%s): empty response\n"
++ , command());
++ }
++
++// +----+-----+-------+------+----------+----------+
++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | Variable | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ m_in_buffer[0] = char(m_version); // version
++ m_in_buffer[1] = 4; // response (host unreachable)
++ m_in_buffer[2] = 0; // reserved
++ m_in_buffer[3] = 1; // IPv4
++ memset(&m_in_buffer[4], 0, 4);
++ m_in_buffer[8] = 0; // port
++ m_in_buffer[9] = 0;
++
++ auto self = shared_from_this();
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], 10)
++ , [=](boost::system::error_code const&, size_t)
++ {
++ self->close_connection();
++ });
++ return;
++ }
++
++ std::printf("socks_connection::on_request_domain_lookup(%s): connecting to: %s port: %d\n"
++ , command()
++ , ips.front().endpoint().address().to_string().c_str()
++ , ips.front().endpoint().port());
++ open_forward_connection(ips.front().endpoint());
++ }
++
++ void socks_connection::open_forward_connection(const asio::ip::tcp::endpoint& target)
++ {
++ std::printf("socks_connection::open_forward_connection(%s): connecting to %s port %d\n"
++ , command(), target.address().to_string().c_str(), target.port());
++
++ m_server_connection.open(target.protocol());
++ m_server_connection.async_connect(target
++ , std::bind(&socks_connection::on_connected, shared_from_this()
++ , std::placeholders::_1));
++ }
++
++ void socks_connection::bind_connection(const asio::ip::tcp::endpoint& target)
++ {
++ std::printf("socks_connection::bind_connection(%s): binding to %s port %d\n"
++ , command(), target.address().to_string().c_str(), target.port());
++
++ error_code ec;
++ m_bind_socket.open(target.protocol(), ec);
++ if (ec)
++ {
++ std::printf("ERROR: open bind socket failed: (%d) %s\n", ec.value()
++ , ec.message().c_str());
++ }
++ else
++ {
++ m_bind_socket.bind(target, ec);
++ }
++
++ int const response = ec
++ ? (m_version == 4 ? 91 : 1)
++ : (m_version == 4 ? 90 : 0);
++ tcp::endpoint ep = m_bind_socket.local_endpoint();
++ int const len = format_response(ep.address(), ep.port(), response);
++
++ if (ec)
++ {
++ std::printf("ERROR: binding socket to %s %d failed: (%d) %s\n"
++ , target.address().to_string().c_str()
++ , target.port()
++ , ec.value()
++ , ec.message().c_str());
++
++ auto self = shared_from_this();
++
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], len)
++ , [=](boost::system::error_code const&, size_t)
++ {
++ self->close_connection();
++ });
++ return;
++ }
++
++ // send response
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], len)
++ , std::bind(&socks_connection::start_accept, shared_from_this(), std::placeholders::_1));
++ }
++
++ void socks_connection::udp_associate(const asio::ip::tcp::endpoint& target)
++ {
++ std::printf("socks_connection::udp_associate(%s): %s:%d\n"
++ , command(), target.address().to_string().c_str(), target.port());
++
++ m_udp_associate_ep.address(target.address());
++ m_udp_associate_ep.port(target.port());
++
++ error_code ec;
++ m_udp_associate.open(m_udp_associate_ep.protocol(), ec);
++ if (ec)
++ {
++ std::printf("ERROR: open UDP associate socket failed: (%d) %s\n", ec.value()
++ , ec.message().c_str());
++ }
++ else
++ {
++ m_udp_associate.bind(udp::endpoint(address_v4(), std::uint16_t(m_bind_port++)), ec);
++ if (ec)
++ {
++ std::printf("ERROR: binding socket failed: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ }
++ else
++ {
++ m_udp_associate.non_blocking(true);
++ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
++ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
++ }
++ }
++
++ int const response = ec ? 1 : 0;
++ udp::endpoint ep = m_udp_associate.local_bound_to();
++ int const len = (m_flags & udp_associate_respond_empty_hostname)
++ ? format_hostname_response("foobar", ep.port(), response)
++ : format_response(ep.address(), ep.port(), response);
++
++ if (ec)
++ {
++ auto self = shared_from_this();
++
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], len)
++ , [=](boost::system::error_code const&, size_t)
++ {
++ self->close_connection();
++ });
++ return;
++ }
++
++ // send response
++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], len)
++ , std::bind(&socks_connection::wait_for_eof, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::wait_for_eof(boost::system::error_code const& ec, std::size_t)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection::wait_for_eof: %s\n", ec.message().c_str());
++ m_udp_associate.close();
++ m_udp_associate_ep = udp::endpoint();
++ m_client_connection.close();
++ return;
++ }
++
++ if (m_flags & socks_flag::disconnect_udp_associate)
++ {
++ std::printf("socks_connection::wait_for_eof: closing connection prematurely\n");
++ m_client_connection.close();
++ return;
++ }
++
++ m_client_connection.async_read_some(
++ asio::buffer(m_out_buffer)
++ , std::bind(&socks_connection::wait_for_eof, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_read_udp(boost::system::error_code const& ec
++ , std::size_t bytes_transferred)
++ {
++ std::printf("socks_connection::on_read_udp\n");
++ if (ec)
++ {
++ std::printf("socks_connection::on_read_udp: %s\n", ec.message().c_str());
++ return;
++ }
++
++ // if the client didn't specify an IP and port it would send packets from,
++ // we assumed the same IP as the TCP connection and assume the port is the
++ // same as the first UDP packet from that host
++ if (m_udp_associate_ep.port() == 0
++ && m_udp_from.address() == m_udp_associate_ep.address())
++ {
++ m_udp_associate_ep.port(m_udp_from.port());
++ }
++
++ if (m_udp_from == m_udp_associate_ep)
++ {
++ // read UDP ASSICOATE header and forward outgoing packet
++ // +----+------+------+----------+----------+----------+
++ // |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
++ // +----+------+------+----------+----------+----------+
++ // | 2 | 1 | 1 | Variable | 2 | Variable |
++ // +----+------+------+----------+----------+----------+
++
++ char const* buf = m_udp_buffer.data();
++ if (buf[2] != 0) std::printf("fragment != 0, not supported\n");
++
++ int const atyp = buf[3];
++ if (atyp == 3)
++ {
++ // hostname
++ int const len = buf[4];
++
++ buf += 5;
++ bytes_transferred -= 5;
++ std::string const hostname(buf, len);
++ buf += len;
++ bytes_transferred -= len;
++
++ std::uint16_t port = buf[0] & 0xff;
++ port <<= 8;
++ port |= buf[1] & 0xff;
++ buf += 2;
++ bytes_transferred -= 2;
++
++ auto it = m_name_mapping.right.find(hostname);
++ if (it != m_name_mapping.right.end())
++ {
++ error_code err;
++ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred)
++ , udp::endpoint(it->second, port), 0, err);
++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
++ return;
++ }
++
++ std::vector<char> forward_buffer(buf, buf + bytes_transferred);
++
++ m_udp_resolver.async_resolve(hostname.c_str(), std::to_string(port).c_str()
++ , [buf=std::move(forward_buffer), hostname, this]
++ (error_code const& ec, asio::ip::udp::resolver::results_type ips)
++ {
++ if (ec)
++ {
++ std::printf("resolve failed: %s\n", ec.message().c_str());
++ return;
++ }
++
++ for (auto const& ip : ips)
++ {
++ auto const target = ip.endpoint();
++ error_code err;
++ m_udp_associate.send_to(boost::asio::buffer(buf)
++ , target, 0, err);
++ if (!err)
++ {
++ m_name_mapping.insert({target.address(), hostname});
++ break;
++ }
++ std::printf("send_to failed: %s\n", err.message().c_str());
++ }
++ });
++ }
++ else if (atyp == 1)
++ {
++ // IPv4
++ std::uint32_t addr = buf[4] & 0xff;
++ addr <<= 8;
++ addr |= buf[5] & 0xff;
++ addr <<= 8;
++ addr |= buf[6] & 0xff;
++ addr <<= 8;
++ addr |= buf[7] & 0xff;
++
++ std::uint16_t port = buf[8] & 0xff;
++ port <<= 8;
++ port |= buf[9] & 0xff;
++
++ buf += 10;
++ bytes_transferred -= 10;
++
++ asio::ip::udp::endpoint const target(address_v4(addr), port);
++
++ error_code err;
++ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred), target, 0, err);
++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
++ }
++ else
++ {
++ std::printf("only supports IPv4 and hostname. ATYP: %d\n", atyp);
++ }
++ }
++ else
++ {
++ std::uint16_t const from_port = m_udp_from.port();
++
++ auto it = m_name_mapping.left.find(m_udp_from.address());
++ if (it != m_name_mapping.left.end())
++ {
++ std::vector<char> header(7 + it->second.size());
++ header[0] = 0; // RSV
++ header[1] = 0;
++ header[2] = 0; // fragment
++ header[3] = 3; // ATYP
++ header[4] = static_cast<char>(it->second.size());
++ int idx = 5;
++ std::copy(it->second.begin(), it->second.end(), header.data() + idx);
++ idx += static_cast<int>(it->second.size());
++ header[idx] = (from_port >> 8) & 0xff;
++ header[idx + 1] = from_port & 0xff;
++
++ std::array<boost::asio::const_buffer, 2> vec{{
++ {header.data(), header.size()},
++ {m_udp_buffer.data(), bytes_transferred}}};
++
++ error_code err;
++ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
++ }
++ else
++ {
++ // add UDP ASSOCIATE header and forward to client
++ std::uint32_t const from_addr = m_udp_from.address().to_v4().to_uint();
++ std::array<char, 10> header;
++ header[0] = 0; // RSV
++ header[1] = 0;
++ header[2] = 0; // fragment
++ header[3] = 1; // ATYP
++ header[4] = (from_addr >> 24) & 0xff; // Address
++ header[5] = (from_addr >> 16) & 0xff;
++ header[6] = (from_addr >> 8) & 0xff;
++ header[7] = (from_addr) & 0xff;
++ header[8] = (from_port >> 8) & 0xff;
++ header[9] = from_port & 0xff;
++
++ std::array<boost::asio::const_buffer, 2> vec{{
++ {header.data(), header.size()},
++ {m_udp_buffer.data(), bytes_transferred}}};
++
++ error_code err;
++ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
++ }
++ }
++
++ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
++ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::start_accept(boost::system::error_code const& ec)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_bind_socket.listen();
++ m_bind_socket.async_accept(m_server_connection
++ , std::bind(&socks_connection::on_connected
++ , shared_from_this(), std::placeholders::_1));
++
++ m_client_connection.async_read_some(
++ sim::asio::buffer(m_out_buffer)
++ , std::bind(&socks_connection::on_client_receive, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ int socks_connection::format_response(address const& addr, int const port
++ , int const response)
++ {
++ int i = 0;
++ if (m_version == 5)
++ {
++// +----+-----+-------+------+----------+----------+
++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | Variable | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ m_in_buffer[i++] = char(m_version); // version
++ m_in_buffer[i++] = char(response); // response
++ m_in_buffer[i++] = 0; // reserved
++ if (addr.is_v4())
++ {
++ m_in_buffer[i++] = 1; // IPv4
++ address_v4::bytes_type b = addr.to_v4().to_bytes();
++ memcpy(&m_in_buffer[i], &b[0], b.size());
++ i += int(b.size());
++ } else {
++ m_in_buffer[i++] = 4; // IPv6
++ address_v6::bytes_type b = addr.to_v6().to_bytes();
++ memcpy(&m_in_buffer[i], &b[0], b.size());
++ i += int(b.size());
++ }
++
++ m_in_buffer[i++] = (port >> 8) & 0xff;
++ m_in_buffer[i++] = port & 0xff;
++ }
++ else
++ {
++ m_in_buffer[i++] = 0; // response version
++ m_in_buffer[i++] = char(response); // return code
++
++ assert(addr.is_v4());
++
++ m_in_buffer[i++] = (port >> 8) & 0xff;
++ m_in_buffer[i++] = port & 0xff;
++
++ address_v4::bytes_type b = addr.to_v4().to_bytes();
++ memcpy(&m_in_buffer[i], &b[0], b.size());
++ i += int(b.size());
++ }
++ return i;
++ }
++
++ int socks_connection::format_hostname_response(char const* hostname, int const port
++ , int const response)
++ {
++ int i = 0;
++ if (m_version != 5)
++ {
++ std::printf("socks_connection: hostname response requires SOCKS v5\n");
++ close_connection();
++ return 0;
++ }
++// +----+-----+-------+------+----------+----------+
++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
++// +----+-----+-------+------+----------+----------+
++// | 1 | 1 | X'00' | 1 | Variable | 2 |
++// +----+-----+-------+------+----------+----------+
++
++ m_in_buffer[i++] = char(m_version); // version
++ m_in_buffer[i++] = char(response); // response
++ m_in_buffer[i++] = 0; // reserved
++ m_in_buffer[i++] = 3; // DOMAINNAME
++ m_in_buffer[i++] = std::uint8_t(::strlen(hostname));
++ for (; *hostname != '\0'; ++hostname)
++ m_in_buffer[i++] = *hostname;
++
++ m_in_buffer[i++] = (port >> 8) & 0xff;
++ m_in_buffer[i++] = port & 0xff;
++ return i;
++ }
++
++ void socks_connection::on_connected(boost::system::error_code const& ec)
++ {
++ std::printf("socks_connection(%s): on_connect: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++
++ if (ec == asio::error::operation_aborted
++ || ec == boost::system::errc::bad_file_descriptor)
++ {
++ return;
++ }
++
++ boost::system::error_code err;
++ asio::ip::tcp::endpoint const ep = m_server_connection.remote_endpoint(err);
++ if (!err)
++ {
++ std::printf("socks_connection(%s): remote_endpoint: %s %d\n"
++ , command(), ep.address().to_string().c_str(), ep.port());
++ }
++
++ int const response = ec
++ ? (m_version == 4 ? 91 : 5)
++ : (m_version == 4 ? 90 : 0);
++ int const len = format_response(ep.address(), ep.port(), response);
++
++ if (ec)
++ {
++ std::printf("socks_connection(%s): failed to connect to/accept from target server: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++
++ auto self = shared_from_this();
++
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], len)
++ , [=](boost::system::error_code const&, size_t)
++ {
++ self->close_connection();
++ });
++ return;
++ }
++
++ auto self = shared_from_this();
++
++ asio::async_write(m_client_connection
++ , asio::buffer(&m_in_buffer[0], len)
++ , [this, self](boost::system::error_code const& ec, size_t)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ return;
++ }
++
++ // read from the client and from the server
++ self->m_server_connection.async_read_some(
++ sim::asio::buffer(m_in_buffer)
++ , std::bind(&socks_connection::on_server_receive, self
++ , std::placeholders::_1, std::placeholders::_2));
++ self->m_client_connection.async_read_some(
++ sim::asio::buffer(m_out_buffer)
++ , std::bind(&socks_connection::on_client_receive, self
++ , std::placeholders::_1, std::placeholders::_2));
++ });
++ }
++
++ // we received some data from the client, forward it to the server
++ void socks_connection::on_client_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred)
++ {
++ // bad file descriptor means the socket has been closed. Whoever closed
++ // the socket will have opened a new one, we cannot call
++ // close_connection()
++ if (ec == asio::error::operation_aborted
++ || ec == boost::system::errc::bad_file_descriptor)
++ return;
++
++ if (ec)
++ {
++ std::printf("socks_connection (%s): error reading from client: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++ asio::async_write(m_server_connection, asio::buffer(&m_out_buffer[0], bytes_transferred)
++ , std::bind(&socks_connection::on_client_forward, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_client_forward(error_code const& ec
++ , size_t /* bytes_transferred */)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection(%s): error writing to server: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_client_connection.async_read_some(
++ sim::asio::buffer(m_out_buffer)
++ , std::bind(&socks_connection::on_client_receive, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ // we received some data from the server, forward it to the server
++ void socks_connection::on_server_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection(%s): error reading from server: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
++ , std::bind(&socks_connection::on_server_forward, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::on_server_forward(error_code const& ec
++ , size_t /* bytes_transferred */)
++ {
++ if (ec)
++ {
++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
++ , command(), ec.value(), ec.message().c_str());
++ close_connection();
++ return;
++ }
++
++ m_server_connection.async_read_some(
++ sim::asio::buffer(m_in_buffer)
++ , std::bind(&socks_connection::on_server_receive, shared_from_this()
++ , std::placeholders::_1, std::placeholders::_2));
++ }
++
++ void socks_connection::close_connection()
++ {
++ error_code err;
++ m_client_connection.close(err);
++ if (err)
++ {
++ std::printf("socks_connection::close: failed to close client connection (%d) %s\n"
++ , err.value(), err.message().c_str());
++ }
++ m_server_connection.close(err);
++ if (err)
++ {
++ std::printf("socks_connection::close: failed to close server connection (%d) %s\n"
++ , err.value(), err.message().c_str());
++ }
++
++ m_bind_socket.close(err);
++ if (err)
++ {
++ std::printf("socks_connection::close: failed to close bind socket (%d) %s\n"
++ , err.value(), err.message().c_str());
++ }
++ }
++
++ char const* socks_connection::command() const
++ {
++ switch (m_command)
++ {
++ case 1: return "CONNECT";
++ case 2: return "BIND";
++ case 3: return "UDP_ASSOCIATE";
++ default: return "UNKNOWN";
++ }
++ }
++}
++
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/tcp_socket.cpp
+@@ -0,0 +1,929 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++#include "simulator/pcap.hpp"
++#include "simulator/handler_allocator.hpp"
++
++#include <functional>
++#include <cinttypes>
++#include <cstdio> // for printf
++
++#include "simulator/push_warnings.hpp"
++#include <boost/system/error_code.hpp>
++#include <boost/function.hpp>
++#include "simulator/pop_warnings.hpp"
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++using namespace std::placeholders;
++
++namespace sim {
++namespace asio {
++namespace ip {
++
++ tcp::socket::socket(io_context& ios)
++ : socket_base(ios)
++ , m_connect_timer(ios)
++ , m_recv_timer(ios)
++ {}
++
++ tcp::socket::socket(socket&& s)
++ : socket_base(std::move(s))
++ , m_connect_handler(std::move(s.m_connect_handler))
++ , m_connect_timer(std::move(s.m_connect_timer))
++ , m_mss(s.m_mss)
++ , m_send_handler(std::move(s.m_send_handler))
++ , m_wait_send_handler(std::move(s.m_wait_send_handler))
++ , m_send_buffer(std::move(s.m_send_buffer))
++ , m_incoming_queue(std::move(s.m_incoming_queue))
++ , m_queue_size(std::move(s.m_queue_size))
++ , m_recv_handler(std::move(s.m_recv_handler))
++ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
++ , m_recv_buffer(std::move(s.m_recv_buffer))
++ , m_recv_timer(std::move(s.m_recv_timer))
++ , m_is_v4(std::move(s.m_is_v4))
++ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
++ , m_send_null_buffers(std::move(s.m_send_null_buffers))
++ , m_channel(std::move(s.m_channel))
++ , m_next_outgoing_seq(std::move(s.m_next_outgoing_seq))
++ , m_next_incoming_seq(std::move(s.m_next_incoming_seq))
++ , m_last_drop_seq(std::move(s.m_last_drop_seq))
++ , m_cwnd(std::move(s.m_cwnd))
++ , m_bytes_in_flight(std::move(s.m_bytes_in_flight))
++ , m_reorder_buffer(std::move(s.m_reorder_buffer))
++ , m_outstanding_packet_sizes(std::move(s.m_outstanding_packet_sizes))
++ , m_outgoing_packets(std::move(s.m_outgoing_packets))
++ {
++ if (m_forwarder) m_forwarder->reset(this);
++ s.m_forwarder.reset();
++ s.m_open = false;
++ s.m_bound_to = ip::tcp::endpoint();
++
++ if (m_bound_to != ip::tcp::endpoint())
++ m_io_service.rebind_socket(&s, this, m_bound_to);
++ }
++
++ tcp::socket::~socket()
++ {
++ boost::system::error_code ec;
++
++ m_channel.reset();
++
++ if (m_bound_to != ip::tcp::endpoint())
++ {
++ m_io_service.unbind_socket(this, m_bound_to);
++ m_bound_to = ip::tcp::endpoint();
++ m_user_bound_to = ip::tcp::endpoint();
++ }
++ m_open = false;
++
++ // prevent any more packets from being delivered to this socket
++ if (m_forwarder)
++ {
++ m_forwarder->reset();
++ m_forwarder.reset();
++ }
++ cancel(ec);
++ }
++
++ void tcp::socket::open(tcp protocol, boost::system::error_code& ec) try
++ {
++ close(ec);
++ m_open = true;
++ m_is_v4 = (protocol == ip::tcp::v4());
++ ec.clear();
++ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ void tcp::socket::open(tcp protocol)
++ {
++ boost::system::error_code ec;
++ open(protocol, ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ // used to attach an incoming connection to this
++ void tcp::socket::internal_connect(tcp::endpoint const& bind_ip
++ , std::shared_ptr<aux::channel> const& c
++ , boost::system::error_code& ec)
++ {
++ open(m_is_v4 ? tcp::v4() : tcp::v6(), ec);
++ if (ec)
++ {
++ std::printf("tcp::socket::internal_connect() error: (%d) %s\n"
++ , ec.value(), ec.message().c_str());
++ return;
++ }
++ m_bound_to = bind_ip;
++ m_user_bound_to = bind_ip;
++ m_channel = c;
++ assert(m_forwarder);
++ c->hops[1].replace_last(m_forwarder);
++ }
++
++ void tcp::socket::bind(ip::tcp::endpoint const& ep
++ , boost::system::error_code& ec) try
++ {
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return;
++ }
++
++ if (ep.address().is_v4() != m_is_v4)
++ {
++ ec = error::address_family_not_supported;
++ return;
++ }
++
++ ip::tcp::endpoint addr = m_io_service.bind_socket(this, ep, ec);
++ if (ec) return;
++ m_bound_to = addr;
++ m_user_bound_to = addr;
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ void tcp::socket::bind(ip::tcp::endpoint const& ep)
++ {
++ boost::system::error_code ec;
++ bind(ep, ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void tcp::socket::close()
++ {
++ boost::system::error_code ec;
++ close(ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void tcp::socket::close(boost::system::error_code& ec) try
++ {
++ if (m_channel)
++ {
++ int const remote = m_channel->remote_idx(m_bound_to);
++ route hops = m_channel->hops[remote];
++
++ // if m_connect_handler is still set, it means the connection hasn't
++ // been established yet, and this channel points to the acceptor
++ // socket, not another open TCP connection.
++ if (!hops.empty() && !m_connect_handler)
++ {
++ aux::packet p;
++ p.type = aux::packet::type_t::error;
++ p.ec = asio::error::eof;
++ p.from = asio::ip::udp::endpoint(
++ m_bound_to.address(), m_bound_to.port());
++ p.overhead = 40;
++ p.hops = hops;
++ p.seq_nr = m_next_outgoing_seq++;
++ send_packet(std::move(p));
++ }
++ m_channel.reset();
++ }
++
++ if (m_bound_to != ip::tcp::endpoint())
++ {
++ m_io_service.unbind_socket(this, m_bound_to);
++ m_bound_to = ip::tcp::endpoint();
++ m_user_bound_to = ip::tcp::endpoint();
++ }
++ m_open = false;
++
++ // prevent any more packets from being delivered to this socket
++ if (m_forwarder)
++ {
++ m_forwarder->reset();
++ m_forwarder.reset();
++ }
++
++ // reset socket state
++ m_queue_size = 0;
++ m_mss = 1475;
++ m_cwnd = m_mss * 2;
++ m_bytes_in_flight = 0;
++ m_outstanding_packet_sizes.clear();
++ m_recv_null_buffers = false;
++ m_send_null_buffers = false;
++ m_next_incoming_seq = 0;
++ m_next_outgoing_seq = 0;
++ m_last_drop_seq = 0;
++
++ cancel(ec);
++
++ ec.clear();
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ std::size_t tcp::socket::available(boost::system::error_code& ec) const
++ {
++ if (!m_open)
++ {
++ ec = boost::system::error_code(error::bad_descriptor);
++ return 0;
++ }
++ if (!m_channel)
++ {
++ ec = boost::system::error_code(error::not_connected);
++ return 0;
++ }
++ if (m_incoming_queue.empty())
++ {
++ return 0;
++ }
++
++ std::size_t ret = 0;
++ for (aux::packet const& p : m_incoming_queue)
++ {
++ if (p.type == aux::packet::type_t::error)
++ {
++ if (ret > 0) return ret;
++
++ // if the read buffer is drained and there is an error, report that
++ // error.
++ ec = p.ec;
++ return 0;
++ }
++ ret += p.buffer.size();
++ }
++ return ret;
++ }
++
++ std::size_t tcp::socket::available() const
++ {
++ boost::system::error_code ec;
++ std::size_t ret = available(ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ void tcp::socket::cancel(boost::system::error_code&)
++ {
++ abort_recv_handlers();
++ abort_send_handlers();
++
++ if (m_connect_handler)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler)
++ , boost::system::error_code(error::operation_aborted))));
++ m_connect_handler = nullptr;
++ }
++ }
++
++ void tcp::socket::cancel()
++ {
++ boost::system::error_code ec;
++ cancel(ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ tcp::endpoint tcp::socket::remote_endpoint(boost::system::error_code& ec) const
++ {
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return tcp::endpoint();
++ }
++
++ if (!m_channel)
++ {
++ ec = error::not_connected;
++ return tcp::endpoint();
++ }
++
++ int const remote = m_channel->remote_idx(m_bound_to);
++ return m_channel->visible_ep[remote];
++ }
++
++ tcp::endpoint tcp::socket::remote_endpoint() const
++ {
++ boost::system::error_code ec;
++ tcp::endpoint ret = remote_endpoint(ec);
++ if (ec) throw boost::system::system_error(ec);
++ return ret;
++ }
++
++ void tcp::socket::async_connect(tcp::endpoint const& target
++ , aux::function<void(boost::system::error_code const&)> h)
++ {
++ if (!m_open) open(target.protocol());
++
++ assert(h);
++ assert(!m_connect_handler);
++
++ // find remote socket
++ boost::system::error_code ec;
++ if (m_bound_to.address() == ip::address())
++ {
++ auto endpoint = ip::tcp::endpoint();
++ if (target.address().is_v4()) {
++ endpoint.address(ip::address_v4::any());
++ } else {
++ endpoint.address(ip::address_v6::any());
++ }
++ ip::tcp::endpoint addr = m_io_service.bind_socket(this
++ , endpoint, ec);
++ if (ec)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(h), ec)));
++ return;
++ }
++ m_bound_to = addr;
++ m_user_bound_to = addr;
++ }
++ if (m_bound_to.address().is_v4() != target.address().is_v4())
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(h),
++ boost::system::error_code(error::address_family_not_supported))));
++ return;
++ }
++ m_channel = m_io_service.internal_connect(this, target, ec);
++ m_mss = m_io_service.get_path_mtu(m_bound_to.address(), target.address());
++ m_cwnd = m_mss * 2;
++ if (ec)
++ {
++ m_channel.reset();
++ // TODO: ask the policy object what the round-trip to this endpoint is
++ m_connect_timer.expires_after(chrono::milliseconds(50));
++ m_connect_timer.async_wait(aux::make_malloc(std::bind(std::move(h), ec)));
++ return;
++ }
++
++ m_connect_handler = std::move(h);
++
++ // the acceptor socket will call internal_connect_complete once the
++ // connection is established
++ }
++
++ void tcp::socket::abort_recv_handlers()
++ {
++ if (m_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_recv_handler)
++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
++
++ if (m_wait_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_recv_handler)
++ , boost::system::error_code(error::operation_aborted))));
++
++ m_recv_timer.cancel();
++ m_recv_handler = nullptr;
++ m_wait_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ m_recv_null_buffers = false;
++ }
++
++ void tcp::socket::abort_send_handlers()
++ {
++ if (m_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_send_handler)
++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
++
++ if (m_wait_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_send_handler)
++ , boost::system::error_code(error::operation_aborted))));
++
++ m_send_handler = nullptr;
++ m_wait_send_handler = nullptr;
++ m_send_buffer.clear();
++ m_send_null_buffers = false;
++ }
++
++ void tcp::socket::async_write_some_impl(std::vector<boost::asio::const_buffer> const& bufs
++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
++ {
++ boost::system::error_code ec;
++ std::size_t const bytes_transferred = write_some_impl(bufs, ec);
++ if (ec == boost::system::error_code(error::would_block))
++ {
++ m_send_handler = std::move(handler);
++ m_send_buffer = bufs;
++ return;
++ }
++
++ if (ec)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
++ m_send_handler = nullptr;
++ m_send_buffer.clear();
++ return;
++ }
++
++ boost::system::error_code no_error;
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), no_error
++ , bytes_transferred)));
++ m_send_handler = nullptr;
++ m_send_buffer.clear();
++ }
++
++ std::size_t tcp::socket::write_some_impl(
++ std::vector<boost::asio::const_buffer> const& bufs
++ , boost::system::error_code& ec)
++ {
++ if (!m_open)
++ {
++ ec = boost::system::error_code(error::bad_descriptor);
++ return 0;
++ }
++ if (!m_channel)
++ {
++ ec = boost::system::error_code(error::not_connected);
++ return 0;
++ }
++
++ // the connect handler is used as proxy that this socket has not competed
++ // the connection yet. We're still waiting for SYN+ACK
++ if (m_connect_handler)
++ {
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ int const remote = m_channel->remote_idx(m_bound_to);
++ route hops = m_channel->hops[remote];
++ if (hops.empty())
++ {
++ ec = boost::system::error_code(error::not_connected);
++ return 0;
++ }
++
++ if (m_bytes_in_flight + m_mss > m_cwnd)
++ {
++ // this indicates that the send buffer is very large, we should
++ // probably not be able to stuff more bytes down it
++ // wait for the receiving end to pop some bytes off
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ std::size_t ret = 0;
++
++ for (auto const& buf : bufs)
++ {
++ // split up in packets
++ int buf_size = int(buf.size());
++ std::uint8_t const* ptr = static_cast<std::uint8_t const*>(buf.data());
++ while (buf_size > 0)
++ {
++ int packet_size = (std::min)(buf_size, m_mss);
++ aux::packet p;
++ p.type = aux::packet::type_t::payload;
++ p.buffer.assign(ptr, ptr + packet_size);
++ p.from = asio::ip::udp::endpoint(
++ m_bound_to.address(), m_bound_to.port());
++ p.overhead = 40;
++ p.hops = hops;
++ p.seq_nr = m_next_outgoing_seq++;
++ p.drop_fun = std::bind(&tcp::socket::packet_dropped, this, _1);
++
++ send_packet(std::move(p));
++ ptr += packet_size;
++ buf_size -= packet_size;
++ ret += packet_size;
++
++ if (m_bytes_in_flight + m_mss > m_cwnd)
++ {
++ // the congestion window is full
++ if (ret == 0)
++ {
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ return ret;
++ }
++ }
++ }
++
++ return ret;
++ }
++
++ std::size_t tcp::socket::read_some_impl(
++ std::vector<boost::asio::mutable_buffer> const& bufs
++ , boost::system::error_code& ec)
++ {
++ // a zero-sized read always completes immediately with 0 bytes;
++ // boost.asio's SSL implementation relies on this to post a
++ // completion handler without transferring any data.
++ if (boost::asio::buffer_size(bufs) == 0)
++ {
++ ec.clear();
++ return 0;
++ }
++
++ assert(!bufs.empty());
++ if (!m_open)
++ {
++ ec = boost::system::error_code(error::bad_descriptor);
++ return 0;
++ }
++ if (!m_channel)
++ {
++ ec = boost::system::error_code(error::not_connected);
++ return 0;
++ }
++ if (m_connect_handler)
++ {
++ // the socket is not done connecting yet
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ if (m_incoming_queue.empty())
++ {
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ typedef std::vector<boost::asio::mutable_buffer> buffers_t;
++ m_recv_buffer = bufs;
++ buffers_t::iterator recv_iter = m_recv_buffer.begin();
++ int total_received = 0;
++ // the offset in the current receive buffer we're writing to. i.e. the
++ // buffer recv_iter points to
++ int buf_offset = 0;
++
++ while (!m_incoming_queue.empty())
++ {
++ aux::packet& p = m_incoming_queue.front();
++
++ if (p.type == aux::packet::type_t::error)
++ {
++ // if we have received bytes also, first deliver those. In the next
++ // read, deliver the error
++ if (total_received > 0) break;
++
++ assert(p.ec);
++ ec = p.ec;
++ m_incoming_queue.erase(m_incoming_queue.begin());
++ m_channel.reset();
++ return 0;
++ }
++ else if (p.type == aux::packet::type_t::payload)
++ {
++ // copy bytes from the incoming queue into the receive buffer.
++ // both are vectors of buffer, so it can get a bit hairy
++ while (recv_iter != m_recv_buffer.end())
++ {
++ int const buf_size = int(recv_iter->size());
++ int const copy_size = (std::min)(int(p.buffer.size())
++ , buf_size - buf_offset);
++
++ memcpy(static_cast<char*>(recv_iter->data()) + buf_offset
++ , p.buffer.data(), copy_size);
++
++ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + copy_size);
++ m_queue_size -= copy_size;
++
++ buf_offset += copy_size;
++ assert(buf_offset <= buf_size);
++ total_received += copy_size;
++ if (buf_offset == buf_size)
++ {
++ ++recv_iter;
++ buf_offset = 0;
++ }
++
++ if (p.buffer.empty())
++ {
++ m_incoming_queue.erase(m_incoming_queue.begin());
++ break;
++ }
++ }
++ }
++ else
++ {
++ assert(false);
++ }
++
++ if (recv_iter == m_recv_buffer.end())
++ break;
++ }
++
++ assert(total_received > 0);
++
++ ec.clear();
++ return total_received;
++ }
++
++ void tcp::socket::async_read_some_impl(std::vector<boost::asio::mutable_buffer> const& bufs
++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
++ {
++ // a zero-sized read always completes immediately with 0 bytes
++ // transferred, regardless of connection or queue state. boost.asio's
++ // SSL implementation relies on this to bounce a completion handler
++ // through the executor without actually transferring any data.
++ if (boost::asio::buffer_size(bufs) == 0)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler)
++ , boost::system::error_code(), std::size_t(0))));
++ return;
++ }
++
++ assert(!bufs.empty());
++
++ boost::system::error_code ec;
++ std::size_t bytes_transferred = read_some_impl(bufs, ec);
++ if (ec == boost::system::error_code(error::would_block))
++ {
++ assert(m_incoming_queue.empty());
++
++ m_recv_buffer = bufs;
++ m_recv_handler = std::move(handler);
++ m_recv_null_buffers = false;
++ return;
++ }
++
++ if (ec)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ return;
++ }
++
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ }
++
++ void tcp::socket::async_wait_read_impl(
++ aux::function<void(boost::system::error_code const&)> handler)
++ {
++ boost::system::error_code ec;
++ // null_buffers notifies the handler when data is available, without
++ // reading any
++ int const bytes = int(available(ec));
++ if (ec)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ return;
++ }
++
++ if (bytes > 0)
++ {
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ return;
++ }
++
++ m_wait_recv_handler = std::move(handler);
++ m_recv_null_buffers = true;
++ }
++
++ void tcp::socket::async_wait_write_impl(
++ aux::function<void(boost::system::error_code const&)> handler)
++ {
++ if (!m_open)
++ {
++ boost::system::error_code const ec(error::bad_descriptor);
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
++ return;
++ }
++
++ if (!m_channel)
++ {
++ boost::system::error_code const ec(error::not_connected);
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
++ return;
++ }
++
++ if (!m_connect_handler && m_bytes_in_flight + m_mss <= m_cwnd)
++ {
++ // the socket is writable right now. complete immediately without
++ // actually writing anything, this is the null_buffers equivalent
++ // for writes
++ boost::system::error_code const ec;
++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
++ return;
++ }
++
++ m_wait_send_handler = std::move(handler);
++ m_send_null_buffers = true;
++ }
++
++ // if there is an outstanding read operation, and this was the first incoming
++ // operation since we last drained, wake up the reader
++ void tcp::socket::maybe_wakeup_reader()
++ {
++ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
++
++ if (m_recv_null_buffers)
++ {
++ async_wait_read_impl(std::move(m_wait_recv_handler));
++ }
++ else
++ {
++ // we have an async. read operation outstanding, and we just put one
++ // packet in our incoming queue.
++
++ // try to read from it and potentially fire the handler
++ async_read_some_impl(m_recv_buffer, std::move(m_recv_handler));
++ }
++ }
++
++ void tcp::socket::maybe_wakeup_writer()
++ {
++ if (!m_send_handler && !m_wait_send_handler) return;
++
++ if (m_send_null_buffers)
++ {
++ async_wait_write_impl(std::move(m_wait_send_handler));
++ }
++ else
++ {
++ // we have an async. write operation outstanding
++ async_write_some_impl(m_send_buffer, std::move(m_send_handler));
++ }
++ }
++
++ bool tcp::socket::internal_is_listening() { return false; }
++
++ void tcp::socket::send_packet(aux::packet p)
++ {
++ m_bytes_in_flight += int(p.buffer.size());
++ m_outstanding_packet_sizes[p.seq_nr] = int(p.buffer.size());
++
++ int const idx = m_channel->self_idx(m_bound_to);
++ p.byte_counter = m_channel->bytes_sent[idx];
++ m_channel->bytes_sent[idx] += std::uint32_t(p.buffer.size());
++
++ auto* log = m_io_service.sim().get_pcap();
++ if (log)
++ {
++ int const remote = m_channel->remote_idx(m_bound_to);
++ log->log_tcp(p, m_bound_to, m_channel->ep[remote]);
++ }
++
++ forward_packet(std::move(p));
++ }
++
++ void tcp::socket::packet_dropped(aux::packet p)
++ {
++ int remote = m_channel->remote_idx(m_bound_to);
++ p.hops = m_channel->hops[remote];
++ m_outgoing_packets.push_back(std::move(p));
++
++ const int packets_in_cwnd = m_cwnd / m_mss;
++
++ // we just recently dropped a packet and cut the cwnd in half,
++ // don't do it again already
++ if (m_last_drop_seq > 0 && p.seq_nr < m_last_drop_seq + packets_in_cwnd) return;
++
++ m_cwnd /= 2;
++ m_last_drop_seq = p.seq_nr;
++
++ // TODO: this should really happen one second later to be accurate
++ if (m_cwnd < m_mss) m_cwnd = m_mss;
++ }
++
++ void tcp::socket::incoming_packet(aux::packet p)
++ {
++ switch (p.type)
++ {
++ case aux::packet::type_t::uninitialized:
++ {
++ assert(false && "uninitialized packet");
++ return;
++ }
++ case aux::packet::type_t::ack:
++ {
++ // if the socket just became writeable, we need to notify the
++ // client. First we want to know whether it was not writeable.
++ const bool was_writeable = m_bytes_in_flight + m_mss > m_cwnd;
++
++ auto it = m_outstanding_packet_sizes.find(p.seq_nr);
++ assert(it != m_outstanding_packet_sizes.end());
++ const int acked_bytes = it->second;
++ m_outstanding_packet_sizes.erase(it);
++ assert(m_bytes_in_flight >= acked_bytes);
++ m_bytes_in_flight -= acked_bytes;
++
++ // potentially resend packets
++ while (!m_outgoing_packets.empty()
++ && m_bytes_in_flight
++ + int(m_outgoing_packets.front().buffer.size()) <= m_cwnd)
++ {
++ aux::packet pkt = std::move(m_outgoing_packets.front());
++ m_outgoing_packets.erase(m_outgoing_packets.begin());
++ send_packet(std::move(pkt));
++ }
++
++ // update cwnd based on the number of bytes ACKed.
++ // every round-trip, increase the window size by one packet
++ // (MSS)
++ m_cwnd += m_mss * acked_bytes / m_cwnd;
++
++ // TODO: implement slow-start
++
++ const bool is_writeable = m_bytes_in_flight + m_mss <= m_cwnd;
++
++ if (!was_writeable && is_writeable)
++ maybe_wakeup_writer();
++
++ return;
++ }
++ case aux::packet::type_t::syn:
++ {
++ // TODO: return connection refused
++ return;
++ }
++ case aux::packet::type_t::syn_ack:
++ {
++ assert(m_connect_handler);
++ boost::system::error_code ec;
++ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler), ec)));
++ m_connect_handler = nullptr;
++ if (ec) m_channel.reset();
++ else maybe_wakeup_writer();
++ return;
++ }
++ case aux::packet::type_t::error:
++ case aux::packet::type_t::payload:
++ {
++ aux::packet ack;
++ ack.type = aux::packet::type_t::ack;
++ ack.seq_nr = p.seq_nr;
++
++ int remote = m_channel->remote_idx(m_bound_to);
++ ack.hops = m_channel->hops[remote];
++ forward_packet(std::move(ack));
++
++ // if the sequence number is out-of-order, put it in the
++ // m_incoming_packets queue
++ if (p.seq_nr != m_next_incoming_seq)
++ {
++ if (p.seq_nr < m_next_incoming_seq)
++ {
++ std::printf("TCP: incoming sequence number lower (%" PRId64 ") "
++ "than expected: %" PRId64 "\n", p.seq_nr, m_next_incoming_seq);
++ }
++
++ m_reorder_buffer.emplace(p.seq_nr, std::move(p));
++ return;
++ }
++
++ // this packet was in-order. increment the expected next sequence
++ // number.
++ ++m_next_incoming_seq;
++ m_incoming_queue.push_back(std::move(p));
++
++ // also, perhaps there are some packets that arrived out-of-order,
++ // check to see
++ auto it = m_reorder_buffer.find(m_next_incoming_seq);
++ while (it != m_reorder_buffer.end())
++ {
++ aux::packet pkt = std::move(it->second);
++ m_reorder_buffer.erase(it);
++ m_incoming_queue.push_back(std::move(pkt));
++ ++m_next_incoming_seq;
++ it = m_reorder_buffer.find(m_next_incoming_seq);
++ }
++
++ maybe_wakeup_reader();
++ return;
++ }
++ }
++ }
++}
++}
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/udp_socket.cpp
+@@ -0,0 +1,492 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include "simulator/packet.hpp"
++#include "simulator/pcap.hpp"
++#include "simulator/handler_allocator.hpp"
++
++#include <functional>
++
++#include "simulator/push_warnings.hpp"
++#include <boost/system/error_code.hpp>
++#include <boost/function.hpp>
++#include "simulator/pop_warnings.hpp"
++
++typedef sim::chrono::high_resolution_clock::time_point time_point;
++typedef sim::chrono::high_resolution_clock::duration duration;
++
++namespace sim {
++namespace asio {
++namespace ip {
++
++ udp::socket::socket(io_context& ios)
++ : socket_base(ios)
++ , m_next_send(chrono::high_resolution_clock::now())
++ , m_recv_sender(nullptr)
++ , m_recv_timer(ios)
++ , m_send_timer(ios)
++ , m_recv_null_buffers(0)
++ , m_queue_size(0)
++ , m_is_v4(true)
++ {}
++
++ udp::socket::socket(socket&& s)
++ : socket_base(std::move(s))
++ , m_next_send(std::move(s.m_next_send))
++ , m_send_handler(std::move(s.m_send_handler))
++ , m_wait_send_handler(std::move(s.m_wait_send_handler))
++ , m_recv_handler(std::move(s.m_recv_handler))
++ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
++ , m_recv_buffer(std::move(s.m_recv_buffer))
++ , m_recv_sender(std::move(s.m_recv_sender))
++ , m_recv_timer(std::move(s.m_recv_timer))
++ , m_send_timer(std::move(s.m_send_timer))
++ , m_incoming_queue(std::move(s.m_incoming_queue))
++ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
++ , m_queue_size(std::move(s.m_queue_size))
++ , m_is_v4(s.m_is_v4)
++ {
++ if (m_forwarder) m_forwarder->reset(this);
++ s.m_forwarder.reset();
++ s.m_open = false;
++ s.m_bound_to = ip::udp::endpoint();
++ if (m_bound_to != ip::udp::endpoint())
++ m_io_service.rebind_udp_socket(this, m_bound_to);
++ }
++
++ udp::socket::~socket()
++ {
++ boost::system::error_code ec;
++ close(ec);
++ }
++
++ void udp::socket::bind(ip::udp::endpoint const& ep
++ , boost::system::error_code& ec) try
++ {
++ if (!m_open)
++ {
++ ec = error::bad_descriptor;
++ return;
++ }
++
++ if (ep.address().is_v4() != m_is_v4)
++ {
++ ec = error::address_family_not_supported;
++ return;
++ }
++
++ ip::udp::endpoint addr = m_io_service.bind_udp_socket(this, ep, ec);
++ if (ec) return;
++ m_bound_to = addr;
++ m_user_bound_to = addr;
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ void udp::socket::bind(ip::udp::endpoint const& ep)
++ {
++ boost::system::error_code ec;
++ bind(ep, ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void udp::socket::open(udp protocol
++ , boost::system::error_code& ec) try
++ {
++ // TODO: what if it's already open?
++ close(ec);
++ m_open = true;
++ m_is_v4 = (protocol == ip::udp::v4());
++ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ void udp::socket::open(udp protocol)
++ {
++ boost::system::error_code ec;
++ open(protocol, ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void udp::socket::close()
++ {
++ boost::system::error_code ec;
++ close(ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void udp::socket::close(boost::system::error_code& ec) try
++ {
++ if (m_bound_to != ip::udp::endpoint())
++ {
++ m_io_service.unbind_udp_socket(this, m_bound_to);
++ m_bound_to = ip::udp::endpoint();
++ m_user_bound_to = ip::udp::endpoint();
++ }
++ m_open = false;
++
++ // prevent any more packets from being delivered to this socket
++ if (m_forwarder)
++ {
++ m_forwarder->reset();
++ m_forwarder.reset();
++ }
++
++ cancel(ec);
++ }
++ catch (std::bad_alloc const&)
++ {
++ ec = make_error_code(boost::system::errc::not_enough_memory);
++ }
++ catch (boost::system::system_error const& err)
++ {
++ ec = err.code();
++ }
++
++ void udp::socket::cancel(boost::system::error_code&)
++ {
++ // cancel outstanding async operations
++ abort_recv_handlers();
++ abort_send_handlers();
++ m_recv_timer.cancel();
++ m_send_timer.cancel();
++ return;
++ }
++
++ void udp::socket::cancel()
++ {
++ boost::system::error_code ec;
++ cancel(ec);
++ if (ec) throw boost::system::system_error(ec);
++ }
++
++ void udp::socket::abort_send_handlers()
++ {
++ if (m_send_handler)
++ post(m_io_service, make_malloc(std::bind(std::ref(m_send_handler)
++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
++
++ if (m_wait_send_handler)
++ post(m_io_service, make_malloc(std::bind(std::ref(m_wait_send_handler)
++ , boost::system::error_code(error::operation_aborted))));
++
++ m_send_timer.cancel();
++ m_send_handler = nullptr;
++ m_wait_send_handler = nullptr;
++// m_send_buffer.clear();
++ }
++
++ void udp::socket::abort_recv_handlers()
++ {
++ if (m_recv_handler)
++ post(m_io_service, make_malloc(std::bind(std::move(m_recv_handler)
++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
++
++ if (m_wait_recv_handler)
++ post(m_io_service, make_malloc(std::bind(std::move(m_wait_recv_handler)
++ , boost::system::error_code(error::operation_aborted))));
++
++ m_recv_timer.cancel();
++ m_recv_handler = nullptr;
++ m_wait_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ }
++
++ void udp::socket::async_wait(socket_base::wait_type_t const w
++ , aux::function<void(boost::system::error_code const&)> handler)
++ {
++ if (w == wait_type_t::wait_write)
++ {
++ abort_send_handlers();
++
++ time_point const now = chrono::high_resolution_clock::now();
++ boost::system::error_code no_error;
++ if (m_next_send - now > m_send_queue_time / 2)
++ {
++ // our send queue is too large. Defer
++ m_recv_timer.expires_at(m_next_send + m_send_queue_time / 2);
++
++ m_wait_send_handler = std::move(handler);
++ m_recv_timer.async_wait(make_malloc(std::bind(std::ref(m_wait_send_handler), no_error)));
++ return;
++ }
++
++ // the socket is writable, post the completion handler immediately
++ post(m_io_service, make_malloc(std::bind(std::move(handler), no_error)));
++ }
++ else if (w == wait_type_t::wait_read)
++ {
++ abort_recv_handlers();
++ async_wait_receive_impl(nullptr, std::move(handler));
++ }
++ }
++
++ std::size_t udp::socket::receive_from_impl(
++ std::vector<asio::mutable_buffer> const& bufs
++ , udp::endpoint* sender
++ , socket_base::message_flags /* flags */
++ , boost::system::error_code& ec)
++ {
++ assert(!bufs.empty());
++ if (!m_open)
++ {
++ ec = boost::system::error_code(error::bad_descriptor);
++ return 0;
++ }
++
++ if (m_bound_to == udp::endpoint())
++ {
++ ec = boost::system::error_code(error::invalid_argument);
++ return 0;
++ }
++
++ if (m_incoming_queue.empty())
++ {
++ ec = boost::system::error_code(error::would_block);
++ return 0;
++ }
++
++ aux::packet& p = m_incoming_queue.front();
++ if (sender) *sender = p.from;
++
++ int read = 0;
++ for (auto const& buf : bufs)
++ {
++ char* ptr = static_cast<char*>(buf.data());
++ int const len = int(buf.size());
++ int const to_copy = (std::min)(int(p.buffer.size()), len);
++ memcpy(ptr, p.buffer.data(), to_copy);
++ read += to_copy;
++ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + to_copy);
++ m_queue_size -= to_copy;
++ if (p.buffer.empty()) break;
++ }
++
++ m_incoming_queue.erase(m_incoming_queue.begin());
++ return read;
++ }
++
++ void udp::socket::async_wait_receive_impl(
++ udp::endpoint* sender
++ , aux::function<void(boost::system::error_code const&)> handler)
++ {
++ if (!m_open)
++ {
++ post(m_io_service, make_malloc(std::bind(std::move(handler)
++ , boost::system::error_code(error::bad_descriptor))));
++ return;
++ }
++
++ if (m_bound_to == udp::endpoint())
++ {
++ post(m_io_service, make_malloc(std::bind(std::move(handler)
++ , boost::system::error_code(error::invalid_argument))));
++ return;
++ }
++
++ if (!m_incoming_queue.empty())
++ {
++ post(m_io_service, make_malloc(std::bind(std::move(handler), boost::system::error_code())));
++ return;
++ }
++
++ m_recv_null_buffers = true;
++ m_wait_recv_handler = std::move(handler);
++ m_recv_sender = sender;
++ }
++
++ void udp::socket::async_receive_from_impl(
++ std::vector<asio::mutable_buffer> const& bufs
++ , udp::endpoint* sender
++ , socket_base::message_flags /* flags */
++ , aux::function<void(boost::system::error_code const&
++ , std::size_t)> handler)
++ {
++ assert(!bufs.empty());
++
++ boost::system::error_code ec;
++ std::size_t bytes_transferred = receive_from_impl(bufs, sender, 0, ec);
++ if (ec == boost::system::error_code(error::would_block))
++ {
++ m_recv_buffer = bufs;
++ m_recv_handler = std::move(handler);
++ m_recv_sender = sender;
++ m_recv_null_buffers = false;
++
++ return;
++ }
++
++ if (ec)
++ {
++ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ m_recv_sender = nullptr;
++ m_recv_null_buffers = false;
++ return;
++ }
++
++ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
++ m_recv_handler = nullptr;
++ m_recv_buffer.clear();
++ m_recv_sender = nullptr;
++ m_recv_null_buffers = false;
++ }
++
++ std::size_t udp::socket::send_to_impl(std::vector<asio::const_buffer> const& b
++ , udp::endpoint const& dst, message_flags /* flags */
++ , boost::system::error_code& ec)
++ {
++ assert(m_non_blocking && "blocking operations not supported");
++
++ if (m_bound_to == ip::udp::endpoint())
++ {
++ // the socket was not bound, bind to anything
++ bind(udp::endpoint(), ec);
++ if (ec) return 0;
++ }
++
++ ec.clear();
++ std::size_t ret = 0;
++ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
++ , end(b.end()); i != end; ++i)
++ {
++ ret += i->size();
++ }
++ if (ret == 0)
++ {
++ ec = boost::system::error_code(error::invalid_argument);
++ return 0;
++ }
++
++ time_point now = chrono::high_resolution_clock::now();
++
++ const int mtu = m_io_service.get_path_mtu(m_bound_to.address(), dst.address());
++
++ if (int(ret) > 65535)
++ {
++ ec = boost::system::error_code(error::message_size);
++ return 0;
++ }
++
++ if (m_dont_fragment && int(ret) > mtu)
++ {
++ // silently drop packet
++ ec.clear();
++ return ret;
++ }
++
++ // determine the bandwidth in terms of nanoseconds / byte
++ const double nanoseconds_per_byte = 1000000000.0
++ / double(aux::nic_bandwidth);
++
++ if (m_next_send - now > m_send_queue_time)
++ {
++ // our send queue is too large.
++ ec = boost::system::error_code(asio::error::would_block);
++ return 0;
++ }
++
++ route hops = m_io_service.find_udp_socket(*this, dst);
++ if (hops.empty())
++ {
++ // the packet is silently dropped
++ // TODO: it would be nice if this would result in a round-trip time
++ // with an ICMP host unreachable or connection_refused error
++ return ret;
++ }
++
++ hops.prepend(m_io_service.get_outgoing_route(m_bound_to.address()));
++
++ m_next_send = std::max(now, m_next_send);
++
++ aux::packet p;
++ p.overhead = 28;
++ p.type = aux::packet::type_t::payload;
++ p.from = m_bound_to;
++ p.hops = hops;
++ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
++ , end(b.end()); i != end; ++i)
++ {
++ p.buffer.insert(p.buffer.end(), static_cast<std::uint8_t const*>(i->data())
++ , static_cast<std::uint8_t const*>(i->data()) + i->size());
++ }
++
++ auto* log = m_io_service.sim().get_pcap();
++ if (log) log->log_udp(p, m_bound_to, dst);
++
++ int const packet_size = int(p.buffer.size() + p.overhead);
++ forward_packet(std::move(p));
++
++ m_next_send += chrono::duration_cast<duration>(chrono::nanoseconds(
++ boost::int64_t(nanoseconds_per_byte * packet_size)));
++
++ return ret;
++ }
++
++ void udp::socket::incoming_packet(aux::packet p)
++ {
++ int const packet_size = int(p.buffer.size() + p.overhead);
++
++ // silent drop. If the application isn't reading fast enough, drop packets
++ // TODO: make this limit controlled by SO_RECVBUF socket option
++ if (m_queue_size + packet_size > 256 * 1024) return;
++
++ m_queue_size += int(p.buffer.size());
++ m_incoming_queue.push_back(std::move(p));
++
++ maybe_wakeup_reader();
++ }
++
++ void udp::socket::maybe_wakeup_reader()
++ {
++ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
++
++ // there is an outstanding operation waiting for an incoming packet
++ if (m_recv_null_buffers)
++ {
++ async_wait_receive_impl(m_recv_sender, std::move(m_wait_recv_handler));
++ }
++ else
++ {
++ async_receive_from_impl(m_recv_buffer, m_recv_sender, 0, std::move(m_recv_handler));
++ }
++
++// m_recv_handler = nullptr;
++// m_recv_buffer.clear();
++// m_recv_sender = nullptr;
++ }
++
++} // ip
++} // asio
++} // sim
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/acceptor.cpp
+@@ -0,0 +1,183 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim::asio;
++using namespace sim::chrono;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++namespace {
++char send_buffer[10000];
++char recv_buffer[10000];
++int num_received = 0;
++int num_sent = 0;
++
++void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
++ , ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ num_sent += int(bytes_transferred);
++
++ std::printf("[%4d] sent %d bytes\n", millis, int(bytes_transferred));
++ std::printf("closing\n");
++ sock.close();
++}
++
++void on_receive(boost::system::error_code const& ec
++ , std::size_t bytes_transferred, ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ num_received += int(bytes_transferred);
++
++ std::printf("[%4d] received %d bytes\n", millis, int(bytes_transferred));
++
++ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
++ , std::bind(&on_receive, _1, _2, std::ref(sock)));
++}
++
++void incoming_connection(boost::system::error_code const& ec
++ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while accepting connection: %s\n"
++ , millis, ec.message().c_str());
++ return;
++ }
++
++ boost::system::error_code err;
++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
++ REQUIRE(!ec);
++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
++ REQUIRE(!ec);
++ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
++ , millis, ep.address().to_string().c_str(), ep.port()
++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
++ CHECK(local_endpoint.port() == 1337);
++ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
++ CHECK(remote_endpoint.port() != 0);
++ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
++
++ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
++ , std::bind(&on_receive, _1, _2, std::ref(sock)));
++}
++
++void on_connected(boost::system::error_code const& ec
++ , ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ boost::system::error_code err;
++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
++ REQUIRE(!ec);
++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
++ REQUIRE(!ec);
++
++ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
++ , millis
++ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
++
++ CHECK(remote_endpoint.port() == 1337);
++ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
++ CHECK(local_endpoint.port() != 0);
++ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
++
++ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
++ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
++}
++
++}
++
++TEST_CASE("accept incoming connection on acceptor socket", "[acceptor]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
++ ip::tcp::acceptor listener(incoming_ios);
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ boost::system::error_code ec;
++ listener.open(ip::tcp::v4(), ec);
++ REQUIRE(!ec);
++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
++ REQUIRE(!ec);
++ listener.listen(10, ec);
++ REQUIRE(!ec);
++
++ ip::tcp::socket incoming(incoming_ios);
++ ip::tcp::endpoint remote_endpoint;
++ listener.async_accept(incoming, remote_endpoint
++ , std::bind(&incoming_connection, _1, std::ref(incoming)
++ , std::cref(remote_endpoint)));
++
++ dump_network_graph(sim, "accept.dot");
++
++ std::printf("[%4d] connecting\n", millis);
++ ip::tcp::socket outgoing(outgoing_ios);
++ outgoing.open(ip::tcp::v4(), ec);
++ REQUIRE(!ec);
++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
++
++ sim.run();
++
++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ CHECK(num_received == num_sent);
++ CHECK(num_received > 0);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/catch.hpp
+@@ -0,0 +1,14057 @@
++
++// Copyright Catch2 Authors
++// Distributed under the Boost Software License, Version 1.0.
++// (See accompanying file LICENSE.txt or copy at
++// https://www.boost.org/LICENSE_1_0.txt)
++
++// SPDX-License-Identifier: BSL-1.0
++
++// Catch v3.6.0
++// Generated: 2024-05-05 20:53:27.071502
++// ----------------------------------------------------------
++// This file is an amalgamation of multiple different files.
++// You probably shouldn't edit it directly.
++// ----------------------------------------------------------
++#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
++#define CATCH_AMALGAMATED_HPP_INCLUDED
++
++
++/** \file
++ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of (significantly) increased
++ * compilation times.
++ *
++ * When a new header is added to either the top level folder, or to the
++ * corresponding internal subfolder, it should be added here. Headers
++ * added to the various subparts (e.g. matchers, generators, etc...),
++ * should go their respective catch-all headers.
++ */
++
++#ifndef CATCH_ALL_HPP_INCLUDED
++#define CATCH_ALL_HPP_INCLUDED
++
++
++
++/** \file
++ * This is a convenience header for Catch2's benchmarking. It includes
++ * **all** of Catch2 headers related to benchmarking.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of (significantly) increased
++ * compilation times.
++ *
++ * When a new header is added to either the `benchmark` folder, or to
++ * the corresponding internal (detail) subfolder, it should be added here.
++ */
++
++#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
++#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_BENCHMARK_HPP_INCLUDED
++#define CATCH_BENCHMARK_HPP_INCLUDED
++
++
++
++#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
++#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
++
++// Detect a number of compiler features - by compiler
++// The following features are defined:
++//
++// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
++// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
++// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
++// ****************
++// Note to maintainers: if new toggles are added please document them
++// in configuration.md, too
++// ****************
++
++// In general each macro has a _NO_<feature name> form
++// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
++// Many features, at point of detection, define an _INTERNAL_ macro, so they
++// can be combined, en-mass, with the _NO_ forms later.
++
++
++
++#ifndef CATCH_PLATFORM_HPP_INCLUDED
++#define CATCH_PLATFORM_HPP_INCLUDED
++
++// See e.g.:
++// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
++#ifdef __APPLE__
++# ifndef __has_extension
++# define __has_extension(x) 0
++# endif
++# include <TargetConditionals.h>
++# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
++ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
++# define CATCH_PLATFORM_MAC
++# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
++# define CATCH_PLATFORM_IPHONE
++# endif
++
++#elif defined(linux) || defined(__linux) || defined(__linux__)
++# define CATCH_PLATFORM_LINUX
++
++#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
++# define CATCH_PLATFORM_WINDOWS
++
++# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
++# define CATCH_PLATFORM_WINDOWS_UWP
++# endif
++
++#elif defined(__ORBIS__) || defined(__PROSPERO__)
++# define CATCH_PLATFORM_PLAYSTATION
++
++#endif
++
++#endif // CATCH_PLATFORM_HPP_INCLUDED
++
++#ifdef __cplusplus
++
++# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
++# define CATCH_CPP17_OR_GREATER
++# endif
++
++# if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
++# define CATCH_CPP20_OR_GREATER
++# endif
++
++#endif
++
++// Only GCC compiler should be used in this block, so other compilers trying to
++// mask themselves as GCC should be ignored.
++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
++
++// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
++// for older versions of GCC.
++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
++ _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
++ _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
++ _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
++ _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
++
++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
++
++#endif
++
++#if defined(__NVCOMPILER)
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" )
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
++#endif
++
++#if defined(__CUDACC__) && !defined(__clang__)
++# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
++// New pragmas introduced in CUDA 11.5+
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" )
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
++# else
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
++# endif
++#endif
++
++// clang-cl defines _MSC_VER as well as __clang__, which could cause the
++// start/stop internal suppression macros to be double defined.
++#if defined(__clang__) && !defined(_MSC_VER)
++
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" )
++
++#endif // __clang__ && !_MSC_VER
++
++#if defined(__clang__)
++
++// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
++// which results in calls to destructors being emitted for each temporary,
++// without a matching initialization. In practice, this can result in something
++// like `std::string::~string` being called on an uninitialized value.
++//
++// For example, this code will likely segfault under IBM XL:
++// ```
++// REQUIRE(std::string("12") + "34" == "1234")
++// ```
++//
++// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
++// results in calls to the immediately evaluated lambda expressions to be
++// reported as unevaluated lambdas.
++// https://developer.nvidia.com/nvidia_bug/3321845.
++//
++// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
++# if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
++# endif
++
++
++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
++ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
++
++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
++
++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
++ _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
++
++#endif // __clang__
++
++
++////////////////////////////////////////////////////////////////////////////////
++// We know some environments not to support full POSIX signals
++#if defined( CATCH_PLATFORM_WINDOWS ) || \
++ defined( CATCH_PLATFORM_PLAYSTATION ) || \
++ defined( __CYGWIN__ ) || \
++ defined( __QNX__ ) || \
++ defined( __EMSCRIPTEN__ ) || \
++ defined( __DJGPP__ ) || \
++ defined( __OS400__ )
++# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
++#else
++# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++// Assume that some platforms do not support getenv.
++#if defined( CATCH_PLATFORM_WINDOWS_UWP ) || \
++ defined( CATCH_PLATFORM_PLAYSTATION ) || \
++ defined( _GAMING_XBOX )
++# define CATCH_INTERNAL_CONFIG_NO_GETENV
++#else
++# define CATCH_INTERNAL_CONFIG_GETENV
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++// Android somehow still does not support std::to_string
++#if defined(__ANDROID__)
++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++// Not all Windows environments support SEH properly
++#if defined(__MINGW32__)
++# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++// PS4
++#if defined(__ORBIS__)
++# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++// Cygwin
++#ifdef __CYGWIN__
++
++// Required for some versions of Cygwin to declare gettimeofday
++// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
++# define _BSD_SOURCE
++// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
++// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
++# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
++ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
++
++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
++
++# endif
++#endif // __CYGWIN__
++
++////////////////////////////////////////////////////////////////////////////////
++// Visual C++
++#if defined(_MSC_VER)
++
++// We want to defer to nvcc-specific warning suppression if we are compiled
++// with nvcc masquerading for MSVC.
++# if !defined( __CUDACC__ )
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ __pragma( warning( push ) )
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ __pragma( warning( pop ) )
++# endif
++
++// Universal Windows platform does not support SEH
++// Or console colours (or console at all...)
++# if defined(CATCH_PLATFORM_WINDOWS_UWP)
++# define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
++# else
++# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
++# endif
++
++// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
++// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
++// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
++# if !defined(__clang__) // Handle Clang masquerading for msvc
++# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
++# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++# endif // MSVC_TRADITIONAL
++# endif // __clang__
++
++#endif // _MSC_VER
++
++#if defined(_REENTRANT) || defined(_MSC_VER)
++// Enable async processing, as -pthread is specified or no additional linking is required
++# define CATCH_INTERNAL_CONFIG_USE_ASYNC
++#endif // _MSC_VER
++
++////////////////////////////////////////////////////////////////////////////////
++// Check if we are compiled with -fno-exceptions or equivalent
++#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
++# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
++#endif
++
++
++////////////////////////////////////////////////////////////////////////////////
++// Embarcadero C++Build
++#if defined(__BORLANDC__)
++ #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
++#endif
++
++////////////////////////////////////////////////////////////////////////////////
++
++// RTX is a special version of Windows that is real time.
++// This means that it is detected as Windows, but does not provide
++// the same set of capabilities as real Windows does.
++#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
++ #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
++ #define CATCH_INTERNAL_CONFIG_NO_ASYNC
++ #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
++#endif
++
++#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
++#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
++#endif
++
++// Various stdlib support checks that require __has_include
++#if defined(__has_include)
++ // Check if string_view is available and usable
++ #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
++ # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
++ #endif
++
++ // Check if optional is available and usable
++ # if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
++ # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
++ # endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
++
++ // Check if byte is available and usable
++ # if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
++ # include <cstddef>
++ # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
++ # define CATCH_INTERNAL_CONFIG_CPP17_BYTE
++ # endif
++ # endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
++
++ // Check if variant is available and usable
++ # if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
++ # if defined(__clang__) && (__clang_major__ < 8)
++ // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
++ // fix should be in clang 8, workaround in libstdc++ 8.2
++ # include <ciso646>
++ # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
++ # define CATCH_CONFIG_NO_CPP17_VARIANT
++ # else
++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
++ # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
++ # else
++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
++ # endif // defined(__clang__) && (__clang_major__ < 8)
++ # endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
++#endif // defined(__has_include)
++
++
++#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
++# define CATCH_CONFIG_WINDOWS_SEH
++#endif
++// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
++#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
++# define CATCH_CONFIG_POSIX_SIGNALS
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
++# define CATCH_CONFIG_GETENV
++#endif
++
++#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
++# define CATCH_CONFIG_CPP11_TO_STRING
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
++# define CATCH_CONFIG_CPP17_OPTIONAL
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
++# define CATCH_CONFIG_CPP17_STRING_VIEW
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
++# define CATCH_CONFIG_CPP17_VARIANT
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
++# define CATCH_CONFIG_CPP17_BYTE
++#endif
++
++
++#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
++# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
++# define CATCH_CONFIG_NEW_CAPTURE
++#endif
++
++#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
++ !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) && \
++ !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
++# define CATCH_CONFIG_DISABLE_EXCEPTIONS
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
++# define CATCH_CONFIG_POLYFILL_ISNAN
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
++# define CATCH_CONFIG_USE_ASYNC
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
++# define CATCH_CONFIG_GLOBAL_NEXTAFTER
++#endif
++
++
++// Even if we do not think the compiler has that warning, we still have
++// to provide a macro that can be used by the code.
++#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
++#endif
++#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
++# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
++#endif
++#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
++#endif
++#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
++#endif
++#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
++# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
++#endif
++#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
++#endif
++
++
++// The goal of this macro is to avoid evaluation of the arguments, but
++// still have the compiler warn on problems inside...
++#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
++#endif
++
++#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
++#elif defined(__clang__) && (__clang_major__ < 5)
++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
++#endif
++
++
++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++#define CATCH_TRY if ((true))
++#define CATCH_CATCH_ALL if ((false))
++#define CATCH_CATCH_ANON(type) if ((false))
++#else
++#define CATCH_TRY try
++#define CATCH_CATCH_ALL catch (...)
++#define CATCH_CATCH_ANON(type) catch (type)
++#endif
++
++#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
++#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++#endif
++
++#if defined( CATCH_PLATFORM_WINDOWS ) && \
++ !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
++ !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
++ !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
++# define CATCH_CONFIG_COLOUR_WIN32
++#endif
++
++#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
++ !defined( CATCH_CONFIG_STATIC )
++# ifdef Catch2_EXPORTS
++# define CATCH_EXPORT //__declspec( dllexport ) // not needed
++# else
++# define CATCH_EXPORT __declspec( dllimport )
++# endif
++#else
++# define CATCH_EXPORT
++#endif
++
++#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
++
++
++#ifndef CATCH_CONTEXT_HPP_INCLUDED
++#define CATCH_CONTEXT_HPP_INCLUDED
++
++
++namespace Catch {
++
++ class IResultCapture;
++ class IConfig;
++
++ class Context {
++ IConfig const* m_config = nullptr;
++ IResultCapture* m_resultCapture = nullptr;
++
++ CATCH_EXPORT static Context* currentContext;
++ friend Context& getCurrentMutableContext();
++ friend Context const& getCurrentContext();
++ static void createContext();
++ friend void cleanUpContext();
++
++ public:
++ IResultCapture* getResultCapture() const { return m_resultCapture; }
++ IConfig const* getConfig() const { return m_config; }
++ void setResultCapture( IResultCapture* resultCapture );
++ void setConfig( IConfig const* config );
++ };
++
++ Context& getCurrentMutableContext();
++
++ inline Context const& getCurrentContext() {
++ // We duplicate the logic from `getCurrentMutableContext` here,
++ // to avoid paying the call overhead in debug mode.
++ if ( !Context::currentContext ) { Context::createContext(); }
++ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
++ return *Context::currentContext;
++ }
++
++ void cleanUpContext();
++
++ class SimplePcg32;
++ SimplePcg32& sharedRng();
++}
++
++#endif // CATCH_CONTEXT_HPP_INCLUDED
++
++
++#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
++#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
++
++#include <type_traits>
++
++//! Replacement for std::move with better compile time performance
++#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
++
++//! Replacement for std::forward with better compile time performance
++#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
++
++#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
++
++
++#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
++#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
++
++namespace Catch {
++
++ //! Used to signal that an assertion macro failed
++ struct TestFailureException{};
++ //! Used to signal that the remainder of a test should be skipped
++ struct TestSkipException {};
++
++ /**
++ * Outlines throwing of `TestFailureException` into a single TU
++ *
++ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
++ */
++ [[noreturn]] void throw_test_failure_exception();
++
++ /**
++ * Outlines throwing of `TestSkipException` into a single TU
++ *
++ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
++ */
++ [[noreturn]] void throw_test_skip_exception();
++
++} // namespace Catch
++
++#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
++
++
++#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
++#define CATCH_UNIQUE_NAME_HPP_INCLUDED
++
++
++
++
++/** \file
++ * Wrapper for the CONFIG configuration option
++ *
++ * When generating internal unique names, there are two options. Either
++ * we mix in the current line number, or mix in an incrementing number.
++ * We prefer the latter, using `__COUNTER__`, but users might want to
++ * use the former.
++ */
++
++#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
++#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
++
++
++#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
++ #define CATCH_INTERNAL_CONFIG_COUNTER
++#endif
++
++#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
++ !defined( CATCH_CONFIG_NO_COUNTER ) && \
++ !defined( CATCH_CONFIG_COUNTER )
++# define CATCH_CONFIG_COUNTER
++#endif
++
++
++#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
++#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
++#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
++#ifdef CATCH_CONFIG_COUNTER
++# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
++#else
++# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
++#endif
++
++#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
++#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
++
++#include <string>
++#include <chrono>
++
++
++
++#ifndef CATCH_STRINGREF_HPP_INCLUDED
++#define CATCH_STRINGREF_HPP_INCLUDED
++
++#include <cstddef>
++#include <string>
++#include <iosfwd>
++#include <cassert>
++
++#include <cstring>
++
++namespace Catch {
++
++ /// A non-owning string class (similar to the forthcoming std::string_view)
++ /// Note that, because a StringRef may be a substring of another string,
++ /// it may not be null terminated.
++ class StringRef {
++ public:
++ using size_type = std::size_t;
++ using const_iterator = const char*;
++
++ static constexpr size_type npos{ static_cast<size_type>( -1 ) };
++
++ private:
++ static constexpr char const* const s_empty = "";
++
++ char const* m_start = s_empty;
++ size_type m_size = 0;
++
++ public: // construction
++ constexpr StringRef() noexcept = default;
++
++ StringRef( char const* rawChars ) noexcept;
++
++ constexpr StringRef( char const* rawChars, size_type size ) noexcept
++ : m_start( rawChars ),
++ m_size( size )
++ {}
++
++ StringRef( std::string const& stdString ) noexcept
++ : m_start( stdString.c_str() ),
++ m_size( stdString.size() )
++ {}
++
++ explicit operator std::string() const {
++ return std::string(m_start, m_size);
++ }
++
++ public: // operators
++ auto operator == ( StringRef other ) const noexcept -> bool {
++ return m_size == other.m_size
++ && (std::memcmp( m_start, other.m_start, m_size ) == 0);
++ }
++ auto operator != (StringRef other) const noexcept -> bool {
++ return !(*this == other);
++ }
++
++ constexpr auto operator[] ( size_type index ) const noexcept -> char {
++ assert(index < m_size);
++ return m_start[index];
++ }
++
++ bool operator<(StringRef rhs) const noexcept;
++
++ public: // named queries
++ constexpr auto empty() const noexcept -> bool {
++ return m_size == 0;
++ }
++ constexpr auto size() const noexcept -> size_type {
++ return m_size;
++ }
++
++ // Returns a substring of [start, start + length).
++ // If start + length > size(), then the substring is [start, size()).
++ // If start > size(), then the substring is empty.
++ constexpr StringRef substr(size_type start, size_type length) const noexcept {
++ if (start < m_size) {
++ const auto shortened_size = m_size - start;
++ return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
++ } else {
++ return StringRef();
++ }
++ }
++
++ // Returns the current start pointer. May not be null-terminated.
++ constexpr char const* data() const noexcept {
++ return m_start;
++ }
++
++ constexpr const_iterator begin() const { return m_start; }
++ constexpr const_iterator end() const { return m_start + m_size; }
++
++
++ friend std::string& operator += (std::string& lhs, StringRef rhs);
++ friend std::ostream& operator << (std::ostream& os, StringRef str);
++ friend std::string operator+(StringRef lhs, StringRef rhs);
++
++ /**
++ * Provides a three-way comparison with rhs
++ *
++ * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
++ * number if lhs > rhs
++ */
++ int compare( StringRef rhs ) const;
++ };
++
++
++ constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
++ return StringRef( rawChars, size );
++ }
++} // namespace Catch
++
++constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
++ return Catch::StringRef( rawChars, size );
++}
++
++#endif // CATCH_STRINGREF_HPP_INCLUDED
++
++
++#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
++#define CATCH_RESULT_TYPE_HPP_INCLUDED
++
++namespace Catch {
++
++ // ResultWas::OfType enum
++ struct ResultWas { enum OfType {
++ Unknown = -1,
++ Ok = 0,
++ Info = 1,
++ Warning = 2,
++ // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
++ ExplicitSkip = 4,
++
++ FailureBit = 0x10,
++
++ ExpressionFailed = FailureBit | 1,
++ ExplicitFailure = FailureBit | 2,
++
++ Exception = 0x100 | FailureBit,
++
++ ThrewException = Exception | 1,
++ DidntThrowException = Exception | 2,
++
++ FatalErrorCondition = 0x200 | FailureBit
++
++ }; };
++
++ bool isOk( ResultWas::OfType resultType );
++ bool isJustInfo( int flags );
++
++
++ // ResultDisposition::Flags enum
++ struct ResultDisposition { enum Flags {
++ Normal = 0x01,
++
++ ContinueOnFailure = 0x02, // Failures fail test, but execution continues
++ FalseTest = 0x04, // Prefix expression with !
++ SuppressFail = 0x08 // Failures are reported but do not fail the test
++ }; };
++
++ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
++
++ bool shouldContinueOnFailure( int flags );
++ inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
++ bool shouldSuppressFailure( int flags );
++
++} // end namespace Catch
++
++#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
++
++
++#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
++#define CATCH_UNIQUE_PTR_HPP_INCLUDED
++
++#include <cassert>
++#include <type_traits>
++
++
++namespace Catch {
++namespace Detail {
++ /**
++ * A reimplementation of `std::unique_ptr` for improved compilation performance
++ *
++ * Does not support arrays nor custom deleters.
++ */
++ template <typename T>
++ class unique_ptr {
++ T* m_ptr;
++ public:
++ constexpr unique_ptr(std::nullptr_t = nullptr):
++ m_ptr{}
++ {}
++ explicit constexpr unique_ptr(T* ptr):
++ m_ptr(ptr)
++ {}
++
++ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
++ unique_ptr(unique_ptr<U>&& from):
++ m_ptr(from.release())
++ {}
++
++ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
++ unique_ptr& operator=(unique_ptr<U>&& from) {
++ reset(from.release());
++
++ return *this;
++ }
++
++ unique_ptr(unique_ptr const&) = delete;
++ unique_ptr& operator=(unique_ptr const&) = delete;
++
++ unique_ptr(unique_ptr&& rhs) noexcept:
++ m_ptr(rhs.m_ptr) {
++ rhs.m_ptr = nullptr;
++ }
++ unique_ptr& operator=(unique_ptr&& rhs) noexcept {
++ reset(rhs.release());
++
++ return *this;
++ }
++
++ ~unique_ptr() {
++ delete m_ptr;
++ }
++
++ T& operator*() {
++ assert(m_ptr);
++ return *m_ptr;
++ }
++ T const& operator*() const {
++ assert(m_ptr);
++ return *m_ptr;
++ }
++ T* operator->() noexcept {
++ assert(m_ptr);
++ return m_ptr;
++ }
++ T const* operator->() const noexcept {
++ assert(m_ptr);
++ return m_ptr;
++ }
++
++ T* get() { return m_ptr; }
++ T const* get() const { return m_ptr; }
++
++ void reset(T* ptr = nullptr) {
++ delete m_ptr;
++ m_ptr = ptr;
++ }
++
++ T* release() {
++ auto temp = m_ptr;
++ m_ptr = nullptr;
++ return temp;
++ }
++
++ explicit operator bool() const {
++ return m_ptr;
++ }
++
++ friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
++ auto temp = lhs.m_ptr;
++ lhs.m_ptr = rhs.m_ptr;
++ rhs.m_ptr = temp;
++ }
++ };
++
++ //! Specialization to cause compile-time error for arrays
++ template <typename T>
++ class unique_ptr<T[]>;
++
++ template <typename T, typename... Args>
++ unique_ptr<T> make_unique(Args&&... args) {
++ return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
++ }
++
++
++} // end namespace Detail
++} // end namespace Catch
++
++#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
++
++
++#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
++#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_CLOCK_HPP_INCLUDED
++#define CATCH_CLOCK_HPP_INCLUDED
++
++#include <chrono>
++
++namespace Catch {
++ namespace Benchmark {
++ using IDuration = std::chrono::nanoseconds;
++ using FDuration = std::chrono::duration<double, std::nano>;
++
++ template <typename Clock>
++ using TimePoint = typename Clock::time_point;
++
++ using default_clock = std::chrono::steady_clock;
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_CLOCK_HPP_INCLUDED
++
++namespace Catch {
++
++ // We cannot forward declare the type with default template argument
++ // multiple times, so it is split out into a separate header so that
++ // we can prevent multiple declarations in dependees
++ template <typename Duration = Benchmark::FDuration>
++ struct BenchmarkStats;
++
++} // end namespace Catch
++
++#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
++
++namespace Catch {
++
++ class AssertionResult;
++ struct AssertionInfo;
++ struct SectionInfo;
++ struct SectionEndInfo;
++ struct MessageInfo;
++ struct MessageBuilder;
++ struct Counts;
++ struct AssertionReaction;
++ struct SourceLineInfo;
++
++ class ITransientExpression;
++ class IGeneratorTracker;
++
++ struct BenchmarkInfo;
++
++ namespace Generators {
++ class GeneratorUntypedBase;
++ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
++ }
++
++
++ class IResultCapture {
++ public:
++ virtual ~IResultCapture();
++
++ virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
++ virtual bool sectionStarted( StringRef sectionName,
++ SourceLineInfo const& sectionLineInfo,
++ Counts& assertions ) = 0;
++ virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
++ virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
++
++ virtual IGeneratorTracker*
++ acquireGeneratorTracker( StringRef generatorName,
++ SourceLineInfo const& lineInfo ) = 0;
++ virtual IGeneratorTracker*
++ createGeneratorTracker( StringRef generatorName,
++ SourceLineInfo lineInfo,
++ Generators::GeneratorBasePtr&& generator ) = 0;
++
++ virtual void benchmarkPreparing( StringRef name ) = 0;
++ virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
++ virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
++ virtual void benchmarkFailed( StringRef error ) = 0;
++
++ virtual void pushScopedMessage( MessageInfo const& message ) = 0;
++ virtual void popScopedMessage( MessageInfo const& message ) = 0;
++
++ virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
++
++ virtual void handleFatalErrorCondition( StringRef message ) = 0;
++
++ virtual void handleExpr
++ ( AssertionInfo const& info,
++ ITransientExpression const& expr,
++ AssertionReaction& reaction ) = 0;
++ virtual void handleMessage
++ ( AssertionInfo const& info,
++ ResultWas::OfType resultType,
++ StringRef message,
++ AssertionReaction& reaction ) = 0;
++ virtual void handleUnexpectedExceptionNotThrown
++ ( AssertionInfo const& info,
++ AssertionReaction& reaction ) = 0;
++ virtual void handleUnexpectedInflightException
++ ( AssertionInfo const& info,
++ std::string&& message,
++ AssertionReaction& reaction ) = 0;
++ virtual void handleIncomplete
++ ( AssertionInfo const& info ) = 0;
++ virtual void handleNonExpr
++ ( AssertionInfo const &info,
++ ResultWas::OfType resultType,
++ AssertionReaction &reaction ) = 0;
++
++
++
++ virtual bool lastAssertionPassed() = 0;
++ virtual void assertionPassed() = 0;
++
++ // Deprecated, do not use:
++ virtual std::string getCurrentTestName() const = 0;
++ virtual const AssertionResult* getLastResult() const = 0;
++ virtual void exceptionEarlyReported() = 0;
++ };
++
++ IResultCapture& getResultCapture();
++}
++
++#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
++#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
++
++
++
++#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
++#define CATCH_NONCOPYABLE_HPP_INCLUDED
++
++namespace Catch {
++ namespace Detail {
++
++ //! Deriving classes become noncopyable and nonmovable
++ class NonCopyable {
++ NonCopyable( NonCopyable const& ) = delete;
++ NonCopyable( NonCopyable&& ) = delete;
++ NonCopyable& operator=( NonCopyable const& ) = delete;
++ NonCopyable& operator=( NonCopyable&& ) = delete;
++
++ protected:
++ NonCopyable() noexcept = default;
++ };
++
++ } // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
++
++#include <chrono>
++#include <iosfwd>
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ enum class Verbosity {
++ Quiet = 0,
++ Normal,
++ High
++ };
++
++ struct WarnAbout { enum What {
++ Nothing = 0x00,
++ //! A test case or leaf section did not run any assertions
++ NoAssertions = 0x01,
++ //! A command line test spec matched no test cases
++ UnmatchedTestSpec = 0x02,
++ }; };
++
++ enum class ShowDurations {
++ DefaultForReporter,
++ Always,
++ Never
++ };
++ enum class TestRunOrder {
++ Declared,
++ LexicographicallySorted,
++ Randomized
++ };
++ enum class ColourMode : std::uint8_t {
++ //! Let Catch2 pick implementation based on platform detection
++ PlatformDefault,
++ //! Use ANSI colour code escapes
++ ANSI,
++ //! Use Win32 console colour API
++ Win32,
++ //! Don't use any colour
++ None
++ };
++ struct WaitForKeypress { enum When {
++ Never,
++ BeforeStart = 1,
++ BeforeExit = 2,
++ BeforeStartAndExit = BeforeStart | BeforeExit
++ }; };
++
++ class TestSpec;
++ class IStream;
++
++ class IConfig : public Detail::NonCopyable {
++ public:
++ virtual ~IConfig();
++
++ virtual bool allowThrows() const = 0;
++ virtual StringRef name() const = 0;
++ virtual bool includeSuccessfulResults() const = 0;
++ virtual bool shouldDebugBreak() const = 0;
++ virtual bool warnAboutMissingAssertions() const = 0;
++ virtual bool warnAboutUnmatchedTestSpecs() const = 0;
++ virtual bool zeroTestsCountAsSuccess() const = 0;
++ virtual int abortAfter() const = 0;
++ virtual bool showInvisibles() const = 0;
++ virtual ShowDurations showDurations() const = 0;
++ virtual double minDuration() const = 0;
++ virtual TestSpec const& testSpec() const = 0;
++ virtual bool hasTestFilters() const = 0;
++ virtual std::vector<std::string> const& getTestsOrTags() const = 0;
++ virtual TestRunOrder runOrder() const = 0;
++ virtual uint32_t rngSeed() const = 0;
++ virtual unsigned int shardCount() const = 0;
++ virtual unsigned int shardIndex() const = 0;
++ virtual ColourMode defaultColourMode() const = 0;
++ virtual std::vector<std::string> const& getSectionsToRun() const = 0;
++ virtual Verbosity verbosity() const = 0;
++
++ virtual bool skipBenchmarks() const = 0;
++ virtual bool benchmarkNoAnalysis() const = 0;
++ virtual unsigned int benchmarkSamples() const = 0;
++ virtual double benchmarkConfidenceInterval() const = 0;
++ virtual unsigned int benchmarkResamples() const = 0;
++ virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
++ };
++}
++
++#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
++#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ class TestCaseHandle;
++ struct TestCaseInfo;
++ class ITestCaseRegistry;
++ class IExceptionTranslatorRegistry;
++ class IExceptionTranslator;
++ class ReporterRegistry;
++ class IReporterFactory;
++ class ITagAliasRegistry;
++ class ITestInvoker;
++ class IMutableEnumValuesRegistry;
++ struct SourceLineInfo;
++
++ class StartupExceptionRegistry;
++ class EventListenerFactory;
++
++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
++
++ class IRegistryHub {
++ public:
++ virtual ~IRegistryHub(); // = default
++
++ virtual ReporterRegistry const& getReporterRegistry() const = 0;
++ virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
++ virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
++ virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
++
++
++ virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
++ };
++
++ class IMutableRegistryHub {
++ public:
++ virtual ~IMutableRegistryHub(); // = default
++ virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
++ virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
++ virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
++ virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
++ virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
++ virtual void registerStartupException() noexcept = 0;
++ virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
++ };
++
++ IRegistryHub const& getRegistryHub();
++ IMutableRegistryHub& getMutableRegistryHub();
++ void cleanUp();
++ std::string translateActiveException();
++
++}
++
++#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
++
++
++#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
++#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_ESTIMATE_HPP_INCLUDED
++#define CATCH_ESTIMATE_HPP_INCLUDED
++
++namespace Catch {
++ namespace Benchmark {
++ template <typename Type>
++ struct Estimate {
++ Type point;
++ Type lower_bound;
++ Type upper_bound;
++ double confidence_interval;
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_ESTIMATE_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
++#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
++
++namespace Catch {
++ namespace Benchmark {
++ struct OutlierClassification {
++ int samples_seen = 0;
++ int low_severe = 0; // more than 3 times IQR below Q1
++ int low_mild = 0; // 1.5 to 3 times IQR below Q1
++ int high_mild = 0; // 1.5 to 3 times IQR above Q3
++ int high_severe = 0; // more than 3 times IQR above Q3
++
++ int total() const {
++ return low_severe + low_mild + high_mild + high_severe;
++ }
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
++// The fwd decl & default specialization needs to be seen by VS2017 before
++// BenchmarkStats itself, or VS2017 will report compilation error.
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ struct BenchmarkInfo {
++ std::string name;
++ double estimatedDuration;
++ int iterations;
++ unsigned int samples;
++ unsigned int resamples;
++ double clockResolution;
++ double clockCost;
++ };
++
++ // We need to keep template parameter for backwards compatibility,
++ // but we also do not want to use the template paraneter.
++ template <class Dummy>
++ struct BenchmarkStats {
++ BenchmarkInfo info;
++
++ std::vector<Benchmark::FDuration> samples;
++ Benchmark::Estimate<Benchmark::FDuration> mean;
++ Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
++ Benchmark::OutlierClassification outliers;
++ double outlierVariance;
++ };
++
++
++} // end namespace Catch
++
++#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
++#define CATCH_ENVIRONMENT_HPP_INCLUDED
++
++
++namespace Catch {
++ namespace Benchmark {
++ struct EnvironmentEstimate {
++ FDuration mean;
++ OutlierClassification outliers;
++ };
++ struct Environment {
++ EnvironmentEstimate clock_resolution;
++ EnvironmentEstimate clock_cost;
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
++#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
++#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
++#define CATCH_CHRONOMETER_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
++#define CATCH_OPTIMIZER_HPP_INCLUDED
++
++#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
++# include <atomic> // atomic_thread_fence
++#endif
++
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++#if defined(__GNUC__) || defined(__clang__)
++ template <typename T>
++ inline void keep_memory(T* p) {
++ asm volatile("" : : "g"(p) : "memory");
++ }
++ inline void keep_memory() {
++ asm volatile("" : : : "memory");
++ }
++
++ namespace Detail {
++ inline void optimizer_barrier() { keep_memory(); }
++ } // namespace Detail
++#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
++
++#if defined(_MSVC_VER)
++#pragma optimize("", off)
++#elif defined(__IAR_SYSTEMS_ICC__)
++// For IAR the pragma only affects the following function
++#pragma optimize=disable
++#endif
++ template <typename T>
++ inline void keep_memory(T* p) {
++ // thanks @milleniumbug
++ *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
++ }
++ // TODO equivalent keep_memory()
++#if defined(_MSVC_VER)
++#pragma optimize("", on)
++#endif
++
++ namespace Detail {
++ inline void optimizer_barrier() {
++ std::atomic_thread_fence(std::memory_order_seq_cst);
++ }
++ } // namespace Detail
++
++#endif
++
++ template <typename T>
++ inline void deoptimize_value(T&& x) {
++ keep_memory(&x);
++ }
++
++ template <typename Fn, typename... Args>
++ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
++ deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
++ }
++
++ template <typename Fn, typename... Args>
++ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
++ CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
++ }
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_OPTIMIZER_HPP_INCLUDED
++
++
++#ifndef CATCH_META_HPP_INCLUDED
++#define CATCH_META_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++ template <typename>
++ struct true_given : std::true_type {};
++
++ struct is_callable_tester {
++ template <typename Fun, typename... Args>
++ static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
++ template <typename...>
++ static std::false_type test(...);
++ };
++
++ template <typename T>
++ struct is_callable;
++
++ template <typename Fun, typename... Args>
++ struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
++
++
++#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
++ // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
++ // replaced with std::invoke_result here.
++ template <typename Func, typename... U>
++ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
++#else
++ template <typename Func, typename... U>
++ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
++#endif
++
++} // namespace Catch
++
++namespace mpl_{
++ struct na;
++}
++
++#endif // CATCH_META_HPP_INCLUDED
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ struct ChronometerConcept {
++ virtual void start() = 0;
++ virtual void finish() = 0;
++ virtual ~ChronometerConcept(); // = default;
++
++ ChronometerConcept() = default;
++ ChronometerConcept(ChronometerConcept const&) = default;
++ ChronometerConcept& operator=(ChronometerConcept const&) = default;
++ };
++ template <typename Clock>
++ struct ChronometerModel final : public ChronometerConcept {
++ void start() override { started = Clock::now(); }
++ void finish() override { finished = Clock::now(); }
++
++ IDuration elapsed() const {
++ return std::chrono::duration_cast<std::chrono::nanoseconds>(
++ finished - started );
++ }
++
++ TimePoint<Clock> started;
++ TimePoint<Clock> finished;
++ };
++ } // namespace Detail
++
++ struct Chronometer {
++ public:
++ template <typename Fun>
++ void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
++
++ int runs() const { return repeats; }
++
++ Chronometer(Detail::ChronometerConcept& meter, int repeats_)
++ : impl(&meter)
++ , repeats(repeats_) {}
++
++ private:
++ template <typename Fun>
++ void measure(Fun&& fun, std::false_type) {
++ measure([&fun](int) { return fun(); }, std::true_type());
++ }
++
++ template <typename Fun>
++ void measure(Fun&& fun, std::true_type) {
++ Detail::optimizer_barrier();
++ impl->start();
++ for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
++ impl->finish();
++ Detail::optimizer_barrier();
++ }
++
++ Detail::ChronometerConcept* impl;
++ int repeats;
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_CHRONOMETER_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename T, typename U>
++ struct is_related
++ : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
++
++ /// We need to reinvent std::function because every piece of code that might add overhead
++ /// in a measurement context needs to have consistent performance characteristics so that we
++ /// can account for it in the measurement.
++ /// Implementations of std::function with optimizations that aren't always applicable, like
++ /// small buffer optimizations, are not uncommon.
++ /// This is effectively an implementation of std::function without any such optimizations;
++ /// it may be slow, but it is consistently slow.
++ struct BenchmarkFunction {
++ private:
++ struct callable {
++ virtual void call(Chronometer meter) const = 0;
++ virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
++ virtual ~callable(); // = default;
++
++ callable() = default;
++ callable(callable const&) = default;
++ callable& operator=(callable const&) = default;
++ };
++ template <typename Fun>
++ struct model : public callable {
++ model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
++ model(Fun const& fun_) : fun(fun_) {}
++
++ Catch::Detail::unique_ptr<callable> clone() const override {
++ return Catch::Detail::make_unique<model<Fun>>( *this );
++ }
++
++ void call(Chronometer meter) const override {
++ call(meter, is_callable<Fun(Chronometer)>());
++ }
++ void call(Chronometer meter, std::true_type) const {
++ fun(meter);
++ }
++ void call(Chronometer meter, std::false_type) const {
++ meter.measure(fun);
++ }
++
++ Fun fun;
++ };
++
++ struct do_nothing { void operator()() const {} };
++
++ template <typename T>
++ BenchmarkFunction(model<T>* c) : f(c) {}
++
++ public:
++ BenchmarkFunction()
++ : f(new model<do_nothing>{ {} }) {}
++
++ template <typename Fun,
++ std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
++ BenchmarkFunction(Fun&& fun)
++ : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
++
++ BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
++ f( CATCH_MOVE( that.f ) ) {}
++
++ BenchmarkFunction(BenchmarkFunction const& that)
++ : f(that.f->clone()) {}
++
++ BenchmarkFunction&
++ operator=( BenchmarkFunction&& that ) noexcept {
++ f = CATCH_MOVE( that.f );
++ return *this;
++ }
++
++ BenchmarkFunction& operator=(BenchmarkFunction const& that) {
++ f = that.f->clone();
++ return *this;
++ }
++
++ void operator()(Chronometer meter) const { f->call(meter); }
++
++ private:
++ Catch::Detail::unique_ptr<callable> f;
++ };
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_REPEAT_HPP_INCLUDED
++#define CATCH_REPEAT_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename Fun>
++ struct repeater {
++ void operator()(int k) const {
++ for (int i = 0; i < k; ++i) {
++ fun();
++ }
++ }
++ Fun fun;
++ };
++ template <typename Fun>
++ repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
++ return { CATCH_FORWARD(fun) };
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_REPEAT_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
++#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_MEASURE_HPP_INCLUDED
++#define CATCH_MEASURE_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
++#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
++
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename T>
++ struct CompleteType { using type = T; };
++ template <>
++ struct CompleteType<void> { struct type {}; };
++
++ template <typename T>
++ using CompleteType_t = typename CompleteType<T>::type;
++
++ template <typename Result>
++ struct CompleteInvoker {
++ template <typename Fun, typename... Args>
++ static Result invoke(Fun&& fun, Args&&... args) {
++ return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
++ }
++ };
++ template <>
++ struct CompleteInvoker<void> {
++ template <typename Fun, typename... Args>
++ static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
++ CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
++ return {};
++ }
++ };
++
++ // invoke and not return void :(
++ template <typename Fun, typename... Args>
++ CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
++ return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
++ }
++
++ } // namespace Detail
++
++ template <typename Fun>
++ Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
++ return Detail::complete_invoke(CATCH_FORWARD(fun));
++ }
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_TIMING_HPP_INCLUDED
++#define CATCH_TIMING_HPP_INCLUDED
++
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++ template <typename Result>
++ struct Timing {
++ IDuration elapsed;
++ Result result;
++ int iterations;
++ };
++ template <typename Func, typename... Args>
++ using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_TIMING_HPP_INCLUDED
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename Clock, typename Fun, typename... Args>
++ TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
++ auto start = Clock::now();
++ auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
++ auto end = Clock::now();
++ auto delta = end - start;
++ return { delta, CATCH_FORWARD(r), 1 };
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_MEASURE_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename Clock, typename Fun>
++ TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
++ return Detail::measure<Clock>(fun, iters);
++ }
++ template <typename Clock, typename Fun>
++ TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
++ Detail::ChronometerModel<Clock> meter;
++ auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
++
++ return { meter.elapsed(), CATCH_MOVE(result), iters };
++ }
++
++ template <typename Clock, typename Fun>
++ using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
++
++
++ [[noreturn]]
++ void throw_optimized_away_error();
++
++ template <typename Clock, typename Fun>
++ TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
++ run_for_at_least(IDuration how_long,
++ const int initial_iterations,
++ Fun&& fun) {
++ auto iters = initial_iterations;
++ while (iters < (1 << 30)) {
++ auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
++
++ if (Timing.elapsed >= how_long) {
++ return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
++ }
++ iters *= 2;
++ }
++ throw_optimized_away_error();
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
++
++#include <vector>
++
++namespace Catch {
++ namespace Benchmark {
++ struct ExecutionPlan {
++ int iterations_per_sample;
++ FDuration estimated_duration;
++ Detail::BenchmarkFunction benchmark;
++ FDuration warmup_time;
++ int warmup_iterations;
++
++ template <typename Clock>
++ std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
++ // warmup a bit
++ Detail::run_for_at_least<Clock>(
++ std::chrono::duration_cast<IDuration>( warmup_time ),
++ warmup_iterations,
++ Detail::repeat( []() { return Clock::now(); } )
++ );
++
++ std::vector<FDuration> times;
++ const auto num_samples = cfg.benchmarkSamples();
++ times.reserve( num_samples );
++ for ( size_t i = 0; i < num_samples; ++i ) {
++ Detail::ChronometerModel<Clock> model;
++ this->benchmark( Chronometer( model, iterations_per_sample ) );
++ auto sample_time = model.elapsed() - env.clock_cost.mean;
++ if ( sample_time < FDuration::zero() ) {
++ sample_time = FDuration::zero();
++ }
++ times.push_back(sample_time / iterations_per_sample);
++ }
++ return times;
++ }
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
++#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_STATS_HPP_INCLUDED
++#define CATCH_STATS_HPP_INCLUDED
++
++
++#include <vector>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ using sample = std::vector<double>;
++
++ double weighted_average_quantile( int k,
++ int q,
++ double* first,
++ double* last );
++
++ OutlierClassification
++ classify_outliers( double const* first, double const* last );
++
++ double mean( double const* first, double const* last );
++
++ double normal_cdf( double x );
++
++ double erfc_inv(double x);
++
++ double normal_quantile(double p);
++
++ Estimate<double>
++ bootstrap( double confidence_level,
++ double* first,
++ double* last,
++ sample const& resample,
++ double ( *estimator )( double const*, double const* ) );
++
++ struct bootstrap_analysis {
++ Estimate<double> mean;
++ Estimate<double> standard_deviation;
++ double outlier_variance;
++ };
++
++ bootstrap_analysis analyse_samples(double confidence_level,
++ unsigned int n_resamples,
++ double* first,
++ double* last);
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_STATS_HPP_INCLUDED
++
++#include <algorithm>
++#include <vector>
++#include <cmath>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename Clock>
++ std::vector<double> resolution(int k) {
++ std::vector<TimePoint<Clock>> times;
++ times.reserve(static_cast<size_t>(k + 1));
++ for ( int i = 0; i < k + 1; ++i ) {
++ times.push_back( Clock::now() );
++ }
++
++ std::vector<double> deltas;
++ deltas.reserve(static_cast<size_t>(k));
++ for ( size_t idx = 1; idx < times.size(); ++idx ) {
++ deltas.push_back( static_cast<double>(
++ ( times[idx] - times[idx - 1] ).count() ) );
++ }
++
++ return deltas;
++ }
++
++ constexpr auto warmup_iterations = 10000;
++ constexpr auto warmup_time = std::chrono::milliseconds(100);
++ constexpr auto minimum_ticks = 1000;
++ constexpr auto warmup_seed = 10000;
++ constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
++ constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
++ constexpr auto clock_cost_estimation_tick_limit = 100000;
++ constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
++ constexpr auto clock_cost_estimation_iterations = 10000;
++
++ template <typename Clock>
++ int warmup() {
++ return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
++ .iterations;
++ }
++ template <typename Clock>
++ EnvironmentEstimate estimate_clock_resolution(int iterations) {
++ auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
++ .result;
++ return {
++ FDuration(mean(r.data(), r.data() + r.size())),
++ classify_outliers(r.data(), r.data() + r.size()),
++ };
++ }
++ template <typename Clock>
++ EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
++ auto time_limit = (std::min)(
++ resolution * clock_cost_estimation_tick_limit,
++ FDuration(clock_cost_estimation_time_limit));
++ auto time_clock = [](int k) {
++ return Detail::measure<Clock>([k] {
++ for (int i = 0; i < k; ++i) {
++ volatile auto ignored = Clock::now();
++ (void)ignored;
++ }
++ }).elapsed;
++ };
++ time_clock(1);
++ int iters = clock_cost_estimation_iterations;
++ auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
++ std::vector<double> times;
++ int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
++ times.reserve(static_cast<size_t>(nsamples));
++ for ( int s = 0; s < nsamples; ++s ) {
++ times.push_back( static_cast<double>(
++ ( time_clock( r.iterations ) / r.iterations )
++ .count() ) );
++ }
++ return {
++ FDuration(mean(times.data(), times.data() + times.size())),
++ classify_outliers(times.data(), times.data() + times.size()),
++ };
++ }
++
++ template <typename Clock>
++ Environment measure_environment() {
++#if defined(__clang__)
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wexit-time-destructors"
++#endif
++ static Catch::Detail::unique_ptr<Environment> env;
++#if defined(__clang__)
++# pragma clang diagnostic pop
++#endif
++ if (env) {
++ return *env;
++ }
++
++ auto iters = Detail::warmup<Clock>();
++ auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
++ auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
++
++ env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
++ return *env;
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_ANALYSE_HPP_INCLUDED
++#define CATCH_ANALYSE_HPP_INCLUDED
++
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
++#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
++
++
++#include <vector>
++
++namespace Catch {
++ namespace Benchmark {
++ struct SampleAnalysis {
++ std::vector<FDuration> samples;
++ Estimate<FDuration> mean;
++ Estimate<FDuration> standard_deviation;
++ OutlierClassification outliers;
++ double outlier_variance;
++ };
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
++
++
++namespace Catch {
++ class IConfig;
++
++ namespace Benchmark {
++ namespace Detail {
++ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_ANALYSE_HPP_INCLUDED
++
++#include <algorithm>
++#include <chrono>
++#include <exception>
++#include <string>
++#include <cmath>
++
++namespace Catch {
++ namespace Benchmark {
++ struct Benchmark {
++ Benchmark(std::string&& benchmarkName)
++ : name(CATCH_MOVE(benchmarkName)) {}
++
++ template <class FUN>
++ Benchmark(std::string&& benchmarkName , FUN &&func)
++ : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
++
++ template <typename Clock>
++ ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
++ auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
++ auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
++ auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
++ int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
++ return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
++ }
++
++ template <typename Clock = default_clock>
++ void run() {
++ static_assert( Clock::is_steady,
++ "Benchmarking clock should be steady" );
++ auto const* cfg = getCurrentContext().getConfig();
++
++ auto env = Detail::measure_environment<Clock>();
++
++ getResultCapture().benchmarkPreparing(name);
++ CATCH_TRY{
++ auto plan = user_code([&] {
++ return prepare<Clock>(*cfg, env);
++ });
++
++ BenchmarkInfo info {
++ CATCH_MOVE(name),
++ plan.estimated_duration.count(),
++ plan.iterations_per_sample,
++ cfg->benchmarkSamples(),
++ cfg->benchmarkResamples(),
++ env.clock_resolution.mean.count(),
++ env.clock_cost.mean.count()
++ };
++
++ getResultCapture().benchmarkStarting(info);
++
++ auto samples = user_code([&] {
++ return plan.template run<Clock>(*cfg, env);
++ });
++
++ auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
++ BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
++ getResultCapture().benchmarkEnded(stats);
++ } CATCH_CATCH_ANON (TestFailureException const&) {
++ getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
++ } CATCH_CATCH_ALL{
++ getResultCapture().benchmarkFailed(translateActiveException());
++ // We let the exception go further up so that the
++ // test case is marked as failed.
++ std::rethrow_exception(std::current_exception());
++ }
++ }
++
++ // sets lambda to be used in fun *and* executes benchmark!
++ template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
++ Benchmark & operator=(Fun func) {
++ auto const* cfg = getCurrentContext().getConfig();
++ if (!cfg->skipBenchmarks()) {
++ fun = Detail::BenchmarkFunction(func);
++ run();
++ }
++ return *this;
++ }
++
++ explicit operator bool() {
++ return true;
++ }
++
++ private:
++ Detail::BenchmarkFunction fun;
++ std::string name;
++ };
++ }
++} // namespace Catch
++
++#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
++#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
++
++#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
++ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
++ BenchmarkName = [&](int benchmarkIndex)
++
++#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
++ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
++ BenchmarkName = [&]
++
++#if defined(CATCH_CONFIG_PREFIX_ALL)
++
++#define CATCH_BENCHMARK(...) \
++ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
++#define CATCH_BENCHMARK_ADVANCED(name) \
++ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
++
++#else
++
++#define BENCHMARK(...) \
++ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
++#define BENCHMARK_ADVANCED(name) \
++ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
++
++#endif
++
++#endif // CATCH_BENCHMARK_HPP_INCLUDED
++
++
++// Adapted from donated nonius code.
++
++#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
++#define CATCH_CONSTRUCTOR_HPP_INCLUDED
++
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ template <typename T, bool Destruct>
++ struct ObjectStorage
++ {
++ ObjectStorage() = default;
++
++ ObjectStorage(const ObjectStorage& other)
++ {
++ new(&data) T(other.stored_object());
++ }
++
++ ObjectStorage(ObjectStorage&& other)
++ {
++ new(data) T(CATCH_MOVE(other.stored_object()));
++ }
++
++ ~ObjectStorage() { destruct_on_exit<T>(); }
++
++ template <typename... Args>
++ void construct(Args&&... args)
++ {
++ new (data) T(CATCH_FORWARD(args)...);
++ }
++
++ template <bool AllowManualDestruction = !Destruct>
++ std::enable_if_t<AllowManualDestruction> destruct()
++ {
++ stored_object().~T();
++ }
++
++ private:
++ // If this is a constructor benchmark, destruct the underlying object
++ template <typename U>
++ void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
++ // Otherwise, don't
++ template <typename U>
++ void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
++
++#if defined( __GNUC__ ) && __GNUC__ <= 6
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wstrict-aliasing"
++#endif
++ T& stored_object() { return *reinterpret_cast<T*>( data ); }
++
++ T const& stored_object() const {
++ return *reinterpret_cast<T const*>( data );
++ }
++#if defined( __GNUC__ ) && __GNUC__ <= 6
++# pragma GCC diagnostic pop
++#endif
++
++ alignas( T ) unsigned char data[sizeof( T )]{};
++ };
++ } // namespace Detail
++
++ template <typename T>
++ using storage_for = Detail::ObjectStorage<T, true>;
++
++ template <typename T>
++ using destructable_object = Detail::ObjectStorage<T, false>;
++ } // namespace Benchmark
++} // namespace Catch
++
++#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
++
++#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
++
++
++#ifndef CATCH_APPROX_HPP_INCLUDED
++#define CATCH_APPROX_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TOSTRING_HPP_INCLUDED
++#define CATCH_TOSTRING_HPP_INCLUDED
++
++
++#include <vector>
++#include <cstddef>
++#include <type_traits>
++#include <string>
++
++
++
++
++/** \file
++ * Wrapper for the WCHAR configuration option
++ *
++ * We want to support platforms that do not provide `wchar_t`, so we
++ * sometimes have to disable providing wchar_t overloads through Catch2,
++ * e.g. the StringMaker specialization for `std::wstring`.
++ */
++
++#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
++#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
++
++
++// We assume that WCHAR should be enabled by default, and only disabled
++// for a shortlist (so far only DJGPP) of compilers.
++
++#if defined(__DJGPP__)
++# define CATCH_INTERNAL_CONFIG_NO_WCHAR
++#endif // __DJGPP__
++
++#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
++ !defined( CATCH_CONFIG_NO_WCHAR ) && \
++ !defined( CATCH_CONFIG_WCHAR )
++# define CATCH_CONFIG_WCHAR
++#endif
++
++#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
++
++
++#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
++#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
++
++
++#include <iosfwd>
++#include <cstddef>
++#include <ostream>
++#include <string>
++
++namespace Catch {
++
++ class ReusableStringStream : Detail::NonCopyable {
++ std::size_t m_index;
++ std::ostream* m_oss;
++ public:
++ ReusableStringStream();
++ ~ReusableStringStream();
++
++ //! Returns the serialized state
++ std::string str() const;
++ //! Sets internal state to `str`
++ void str(std::string const& str);
++
++#if defined(__GNUC__) && !defined(__clang__)
++#pragma GCC diagnostic push
++// Old versions of GCC do not understand -Wnonnull-compare
++#pragma GCC diagnostic ignored "-Wpragmas"
++// Streaming a function pointer triggers Waddress and Wnonnull-compare
++// on GCC, because it implicitly converts it to bool and then decides
++// that the check it uses (a? true : false) is tautological and cannot
++// be null...
++#pragma GCC diagnostic ignored "-Waddress"
++#pragma GCC diagnostic ignored "-Wnonnull-compare"
++#endif
++
++ template<typename T>
++ auto operator << ( T const& value ) -> ReusableStringStream& {
++ *m_oss << value;
++ return *this;
++ }
++
++#if defined(__GNUC__) && !defined(__clang__)
++#pragma GCC diagnostic pop
++#endif
++ auto get() -> std::ostream& { return *m_oss; }
++ };
++}
++
++#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
++
++
++#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
++#define CATCH_VOID_TYPE_HPP_INCLUDED
++
++
++namespace Catch {
++ namespace Detail {
++
++ template <typename...>
++ struct make_void { using type = void; };
++
++ template <typename... Ts>
++ using void_t = typename make_void<Ts...>::type;
++
++ } // namespace Detail
++} // namespace Catch
++
++
++#endif // CATCH_VOID_TYPE_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++
++
++#include <vector>
++
++namespace Catch {
++
++ namespace Detail {
++ struct EnumInfo {
++ StringRef m_name;
++ std::vector<std::pair<int, StringRef>> m_values;
++
++ ~EnumInfo();
++
++ StringRef lookup( int value ) const;
++ };
++ } // namespace Detail
++
++ class IMutableEnumValuesRegistry {
++ public:
++ virtual ~IMutableEnumValuesRegistry(); // = default;
++
++ virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
++
++ template<typename E>
++ Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
++ static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
++ std::vector<int> intValues;
++ intValues.reserve( values.size() );
++ for( auto enumValue : values )
++ intValues.push_back( static_cast<int>( enumValue ) );
++ return registerEnum( enumName, allEnums, intValues );
++ }
++ };
++
++} // Catch
++
++#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++
++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
++#include <string_view>
++#endif
++
++#ifdef _MSC_VER
++#pragma warning(push)
++#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
++#endif
++
++// We need a dummy global operator<< so we can bring it into Catch namespace later
++struct Catch_global_namespace_dummy{};
++std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
++
++namespace Catch {
++ // Bring in global namespace operator<< for ADL lookup in
++ // `IsStreamInsertable` below.
++ using ::operator<<;
++
++ namespace Detail {
++
++ inline std::size_t catch_strnlen(const char *str, std::size_t n) {
++ auto ret = std::char_traits<char>::find(str, n, '\0');
++ if (ret != nullptr) {
++ return static_cast<std::size_t>(ret - str);
++ }
++ return n;
++ }
++
++ constexpr StringRef unprintableString = "{?}"_sr;
++
++ //! Encases `string in quotes, and optionally escapes invisibles
++ std::string convertIntoString( StringRef string, bool escapeInvisibles );
++
++ //! Encases `string` in quotes, and escapes invisibles if user requested
++ //! it via CLI
++ std::string convertIntoString( StringRef string );
++
++ std::string rawMemoryToString( const void *object, std::size_t size );
++
++ template<typename T>
++ std::string rawMemoryToString( const T& object ) {
++ return rawMemoryToString( &object, sizeof(object) );
++ }
++
++ template<typename T>
++ class IsStreamInsertable {
++ template<typename Stream, typename U>
++ static auto test(int)
++ -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
++
++ template<typename, typename>
++ static auto test(...)->std::false_type;
++
++ public:
++ static const bool value = decltype(test<std::ostream, const T&>(0))::value;
++ };
++
++ template<typename E>
++ std::string convertUnknownEnumToString( E e );
++
++ template<typename T>
++ std::enable_if_t<
++ !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
++ std::string> convertUnstreamable( T const& ) {
++ return std::string(Detail::unprintableString);
++ }
++ template<typename T>
++ std::enable_if_t<
++ !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
++ std::string> convertUnstreamable(T const& ex) {
++ return ex.what();
++ }
++
++
++ template<typename T>
++ std::enable_if_t<
++ std::is_enum<T>::value,
++ std::string> convertUnstreamable( T const& value ) {
++ return convertUnknownEnumToString( value );
++ }
++
++#if defined(_MANAGED)
++ //! Convert a CLR string to a utf8 std::string
++ template<typename T>
++ std::string clrReferenceToString( T^ ref ) {
++ if (ref == nullptr)
++ return std::string("null");
++ auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
++ cli::pin_ptr<System::Byte> p = &bytes[0];
++ return std::string(reinterpret_cast<char const *>(p), bytes->Length);
++ }
++#endif
++
++ } // namespace Detail
++
++
++ template <typename T, typename = void>
++ struct StringMaker {
++ template <typename Fake = T>
++ static
++ std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
++ convert(const Fake& value) {
++ ReusableStringStream rss;
++ // NB: call using the function-like syntax to avoid ambiguity with
++ // user-defined templated operator<< under clang.
++ rss.operator<<(value);
++ return rss.str();
++ }
++
++ template <typename Fake = T>
++ static
++ std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
++ convert( const Fake& value ) {
++#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
++ return Detail::convertUnstreamable(value);
++#else
++ return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
++#endif
++ }
++ };
++
++ namespace Detail {
++
++ // This function dispatches all stringification requests inside of Catch.
++ // Should be preferably called fully qualified, like ::Catch::Detail::stringify
++ template <typename T>
++ std::string stringify(const T& e) {
++ return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
++ }
++
++ template<typename E>
++ std::string convertUnknownEnumToString( E e ) {
++ return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
++ }
++
++#if defined(_MANAGED)
++ template <typename T>
++ std::string stringify( T^ e ) {
++ return ::Catch::StringMaker<T^>::convert(e);
++ }
++#endif
++
++ } // namespace Detail
++
++ // Some predefined specializations
++
++ template<>
++ struct StringMaker<std::string> {
++ static std::string convert(const std::string& str);
++ };
++
++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
++ template<>
++ struct StringMaker<std::string_view> {
++ static std::string convert(std::string_view str);
++ };
++#endif
++
++ template<>
++ struct StringMaker<char const *> {
++ static std::string convert(char const * str);
++ };
++ template<>
++ struct StringMaker<char *> {
++ static std::string convert(char * str);
++ };
++
++#if defined(CATCH_CONFIG_WCHAR)
++ template<>
++ struct StringMaker<std::wstring> {
++ static std::string convert(const std::wstring& wstr);
++ };
++
++# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
++ template<>
++ struct StringMaker<std::wstring_view> {
++ static std::string convert(std::wstring_view str);
++ };
++# endif
++
++ template<>
++ struct StringMaker<wchar_t const *> {
++ static std::string convert(wchar_t const * str);
++ };
++ template<>
++ struct StringMaker<wchar_t *> {
++ static std::string convert(wchar_t * str);
++ };
++#endif // CATCH_CONFIG_WCHAR
++
++ template<size_t SZ>
++ struct StringMaker<char[SZ]> {
++ static std::string convert(char const* str) {
++ return Detail::convertIntoString(
++ StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
++ }
++ };
++ template<size_t SZ>
++ struct StringMaker<signed char[SZ]> {
++ static std::string convert(signed char const* str) {
++ auto reinterpreted = reinterpret_cast<char const*>(str);
++ return Detail::convertIntoString(
++ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
++ }
++ };
++ template<size_t SZ>
++ struct StringMaker<unsigned char[SZ]> {
++ static std::string convert(unsigned char const* str) {
++ auto reinterpreted = reinterpret_cast<char const*>(str);
++ return Detail::convertIntoString(
++ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
++ }
++ };
++
++#if defined(CATCH_CONFIG_CPP17_BYTE)
++ template<>
++ struct StringMaker<std::byte> {
++ static std::string convert(std::byte value);
++ };
++#endif // defined(CATCH_CONFIG_CPP17_BYTE)
++ template<>
++ struct StringMaker<int> {
++ static std::string convert(int value);
++ };
++ template<>
++ struct StringMaker<long> {
++ static std::string convert(long value);
++ };
++ template<>
++ struct StringMaker<long long> {
++ static std::string convert(long long value);
++ };
++ template<>
++ struct StringMaker<unsigned int> {
++ static std::string convert(unsigned int value);
++ };
++ template<>
++ struct StringMaker<unsigned long> {
++ static std::string convert(unsigned long value);
++ };
++ template<>
++ struct StringMaker<unsigned long long> {
++ static std::string convert(unsigned long long value);
++ };
++
++ template<>
++ struct StringMaker<bool> {
++ static std::string convert(bool b) {
++ using namespace std::string_literals;
++ return b ? "true"s : "false"s;
++ }
++ };
++
++ template<>
++ struct StringMaker<char> {
++ static std::string convert(char c);
++ };
++ template<>
++ struct StringMaker<signed char> {
++ static std::string convert(signed char value);
++ };
++ template<>
++ struct StringMaker<unsigned char> {
++ static std::string convert(unsigned char value);
++ };
++
++ template<>
++ struct StringMaker<std::nullptr_t> {
++ static std::string convert(std::nullptr_t) {
++ using namespace std::string_literals;
++ return "nullptr"s;
++ }
++ };
++
++ template<>
++ struct StringMaker<float> {
++ static std::string convert(float value);
++ CATCH_EXPORT static int precision;
++ };
++
++ template<>
++ struct StringMaker<double> {
++ static std::string convert(double value);
++ CATCH_EXPORT static int precision;
++ };
++
++ template <typename T>
++ struct StringMaker<T*> {
++ template <typename U>
++ static std::string convert(U* p) {
++ if (p) {
++ return ::Catch::Detail::rawMemoryToString(p);
++ } else {
++ return "nullptr";
++ }
++ }
++ };
++
++ template <typename R, typename C>
++ struct StringMaker<R C::*> {
++ static std::string convert(R C::* p) {
++ if (p) {
++ return ::Catch::Detail::rawMemoryToString(p);
++ } else {
++ return "nullptr";
++ }
++ }
++ };
++
++#if defined(_MANAGED)
++ template <typename T>
++ struct StringMaker<T^> {
++ static std::string convert( T^ ref ) {
++ return ::Catch::Detail::clrReferenceToString(ref);
++ }
++ };
++#endif
++
++ namespace Detail {
++ template<typename InputIterator, typename Sentinel = InputIterator>
++ std::string rangeToString(InputIterator first, Sentinel last) {
++ ReusableStringStream rss;
++ rss << "{ ";
++ if (first != last) {
++ rss << ::Catch::Detail::stringify(*first);
++ for (++first; first != last; ++first)
++ rss << ", " << ::Catch::Detail::stringify(*first);
++ }
++ rss << " }";
++ return rss.str();
++ }
++ }
++
++} // namespace Catch
++
++//////////////////////////////////////////////////////
++// Separate std-lib types stringification, so it can be selectively enabled
++// This means that we do not bring in their headers
++
++#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
++# define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
++# define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
++# define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
++# define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
++#endif
++
++// Separate std::pair specialization
++#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
++#include <utility>
++namespace Catch {
++ template<typename T1, typename T2>
++ struct StringMaker<std::pair<T1, T2> > {
++ static std::string convert(const std::pair<T1, T2>& pair) {
++ ReusableStringStream rss;
++ rss << "{ "
++ << ::Catch::Detail::stringify(pair.first)
++ << ", "
++ << ::Catch::Detail::stringify(pair.second)
++ << " }";
++ return rss.str();
++ }
++ };
++}
++#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
++
++#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
++#include <optional>
++namespace Catch {
++ template<typename T>
++ struct StringMaker<std::optional<T> > {
++ static std::string convert(const std::optional<T>& optional) {
++ if (optional.has_value()) {
++ return ::Catch::Detail::stringify(*optional);
++ } else {
++ return "{ }";
++ }
++ }
++ };
++ template <>
++ struct StringMaker<std::nullopt_t> {
++ static std::string convert(const std::nullopt_t&) {
++ return "{ }";
++ }
++ };
++}
++#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
++
++// Separate std::tuple specialization
++#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
++#include <tuple>
++namespace Catch {
++ namespace Detail {
++ template<
++ typename Tuple,
++ std::size_t N = 0,
++ bool = (N < std::tuple_size<Tuple>::value)
++ >
++ struct TupleElementPrinter {
++ static void print(const Tuple& tuple, std::ostream& os) {
++ os << (N ? ", " : " ")
++ << ::Catch::Detail::stringify(std::get<N>(tuple));
++ TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
++ }
++ };
++
++ template<
++ typename Tuple,
++ std::size_t N
++ >
++ struct TupleElementPrinter<Tuple, N, false> {
++ static void print(const Tuple&, std::ostream&) {}
++ };
++
++ }
++
++
++ template<typename ...Types>
++ struct StringMaker<std::tuple<Types...>> {
++ static std::string convert(const std::tuple<Types...>& tuple) {
++ ReusableStringStream rss;
++ rss << '{';
++ Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
++ rss << " }";
++ return rss.str();
++ }
++ };
++}
++#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
++
++#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
++#include <variant>
++namespace Catch {
++ template<>
++ struct StringMaker<std::monostate> {
++ static std::string convert(const std::monostate&) {
++ return "{ }";
++ }
++ };
++
++ template<typename... Elements>
++ struct StringMaker<std::variant<Elements...>> {
++ static std::string convert(const std::variant<Elements...>& variant) {
++ if (variant.valueless_by_exception()) {
++ return "{valueless variant}";
++ } else {
++ return std::visit(
++ [](const auto& value) {
++ return ::Catch::Detail::stringify(value);
++ },
++ variant
++ );
++ }
++ }
++ };
++}
++#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
++
++namespace Catch {
++ // Import begin/ end from std here
++ using std::begin;
++ using std::end;
++
++ namespace Detail {
++ template <typename T, typename = void>
++ struct is_range_impl : std::false_type {};
++
++ template <typename T>
++ struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
++ } // namespace Detail
++
++ template <typename T>
++ struct is_range : Detail::is_range_impl<T> {};
++
++#if defined(_MANAGED) // Managed types are never ranges
++ template <typename T>
++ struct is_range<T^> {
++ static const bool value = false;
++ };
++#endif
++
++ template<typename Range>
++ std::string rangeToString( Range const& range ) {
++ return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
++ }
++
++ // Handle vector<bool> specially
++ template<typename Allocator>
++ std::string rangeToString( std::vector<bool, Allocator> const& v ) {
++ ReusableStringStream rss;
++ rss << "{ ";
++ bool first = true;
++ for( bool b : v ) {
++ if( first )
++ first = false;
++ else
++ rss << ", ";
++ rss << ::Catch::Detail::stringify( b );
++ }
++ rss << " }";
++ return rss.str();
++ }
++
++ template<typename R>
++ struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
++ static std::string convert( R const& range ) {
++ return rangeToString( range );
++ }
++ };
++
++ template <typename T, size_t SZ>
++ struct StringMaker<T[SZ]> {
++ static std::string convert(T const(&arr)[SZ]) {
++ return rangeToString(arr);
++ }
++ };
++
++
++} // namespace Catch
++
++// Separate std::chrono::duration specialization
++#include <ctime>
++#include <ratio>
++#include <chrono>
++
++
++namespace Catch {
++
++template <class Ratio>
++struct ratio_string {
++ static std::string symbol() {
++ Catch::ReusableStringStream rss;
++ rss << '[' << Ratio::num << '/'
++ << Ratio::den << ']';
++ return rss.str();
++ }
++};
++
++template <>
++struct ratio_string<std::atto> {
++ static char symbol() { return 'a'; }
++};
++template <>
++struct ratio_string<std::femto> {
++ static char symbol() { return 'f'; }
++};
++template <>
++struct ratio_string<std::pico> {
++ static char symbol() { return 'p'; }
++};
++template <>
++struct ratio_string<std::nano> {
++ static char symbol() { return 'n'; }
++};
++template <>
++struct ratio_string<std::micro> {
++ static char symbol() { return 'u'; }
++};
++template <>
++struct ratio_string<std::milli> {
++ static char symbol() { return 'm'; }
++};
++
++ ////////////
++ // std::chrono::duration specializations
++ template<typename Value, typename Ratio>
++ struct StringMaker<std::chrono::duration<Value, Ratio>> {
++ static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
++ ReusableStringStream rss;
++ rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
++ return rss.str();
++ }
++ };
++ template<typename Value>
++ struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
++ static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
++ ReusableStringStream rss;
++ rss << duration.count() << " s";
++ return rss.str();
++ }
++ };
++ template<typename Value>
++ struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
++ static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
++ ReusableStringStream rss;
++ rss << duration.count() << " m";
++ return rss.str();
++ }
++ };
++ template<typename Value>
++ struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
++ static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
++ ReusableStringStream rss;
++ rss << duration.count() << " h";
++ return rss.str();
++ }
++ };
++
++ ////////////
++ // std::chrono::time_point specialization
++ // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
++ template<typename Clock, typename Duration>
++ struct StringMaker<std::chrono::time_point<Clock, Duration>> {
++ static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
++ return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
++ }
++ };
++ // std::chrono::time_point<system_clock> specialization
++ template<typename Duration>
++ struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
++ static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
++ auto converted = std::chrono::system_clock::to_time_t(time_point);
++
++#ifdef _MSC_VER
++ std::tm timeInfo = {};
++ gmtime_s(&timeInfo, &converted);
++#else
++ std::tm* timeInfo = std::gmtime(&converted);
++#endif
++
++ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
++ char timeStamp[timeStampSize];
++ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
++
++#ifdef _MSC_VER
++ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
++#else
++ std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
++#endif
++ return std::string(timeStamp, timeStampSize - 1);
++ }
++ };
++}
++
++
++#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
++namespace Catch { \
++ template<> struct StringMaker<enumName> { \
++ static std::string convert( enumName value ) { \
++ static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
++ return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
++ } \
++ }; \
++}
++
++#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++
++#endif // CATCH_TOSTRING_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++
++ class Approx {
++ private:
++ bool equalityComparisonImpl(double other) const;
++ // Sets and validates the new margin (margin >= 0)
++ void setMargin(double margin);
++ // Sets and validates the new epsilon (0 < epsilon < 1)
++ void setEpsilon(double epsilon);
++
++ public:
++ explicit Approx ( double value );
++
++ static Approx custom();
++
++ Approx operator-() const;
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ Approx operator()( T const& value ) const {
++ Approx approx( static_cast<double>(value) );
++ approx.m_epsilon = m_epsilon;
++ approx.m_margin = m_margin;
++ approx.m_scale = m_scale;
++ return approx;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ explicit Approx( T const& value ): Approx(static_cast<double>(value))
++ {}
++
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator == ( const T& lhs, Approx const& rhs ) {
++ auto lhs_v = static_cast<double>(lhs);
++ return rhs.equalityComparisonImpl(lhs_v);
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator == ( Approx const& lhs, const T& rhs ) {
++ return operator==( rhs, lhs );
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator != ( T const& lhs, Approx const& rhs ) {
++ return !operator==( lhs, rhs );
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator != ( Approx const& lhs, T const& rhs ) {
++ return !operator==( rhs, lhs );
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator <= ( T const& lhs, Approx const& rhs ) {
++ return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator <= ( Approx const& lhs, T const& rhs ) {
++ return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator >= ( T const& lhs, Approx const& rhs ) {
++ return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ friend bool operator >= ( Approx const& lhs, T const& rhs ) {
++ return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ Approx& epsilon( T const& newEpsilon ) {
++ const auto epsilonAsDouble = static_cast<double>(newEpsilon);
++ setEpsilon(epsilonAsDouble);
++ return *this;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ Approx& margin( T const& newMargin ) {
++ const auto marginAsDouble = static_cast<double>(newMargin);
++ setMargin(marginAsDouble);
++ return *this;
++ }
++
++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ Approx& scale( T const& newScale ) {
++ m_scale = static_cast<double>(newScale);
++ return *this;
++ }
++
++ std::string toString() const;
++
++ private:
++ double m_epsilon;
++ double m_margin;
++ double m_scale;
++ double m_value;
++ };
++
++namespace literals {
++ Approx operator ""_a(long double val);
++ Approx operator ""_a(unsigned long long val);
++} // end namespace literals
++
++template<>
++struct StringMaker<Catch::Approx> {
++ static std::string convert(Catch::Approx const& value);
++};
++
++} // end namespace Catch
++
++#endif // CATCH_APPROX_HPP_INCLUDED
++
++
++#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
++#define CATCH_ASSERTION_INFO_HPP_INCLUDED
++
++
++
++#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
++#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
++
++#include <cstddef>
++#include <iosfwd>
++
++namespace Catch {
++
++ struct SourceLineInfo {
++
++ SourceLineInfo() = delete;
++ constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
++ file( _file ),
++ line( _line )
++ {}
++
++ bool operator == ( SourceLineInfo const& other ) const noexcept;
++ bool operator < ( SourceLineInfo const& other ) const noexcept;
++
++ char const* file;
++ std::size_t line;
++
++ friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
++ };
++}
++
++#define CATCH_INTERNAL_LINEINFO \
++ ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
++
++#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
++
++namespace Catch {
++
++ struct AssertionInfo {
++ // AssertionInfo() = delete;
++
++ StringRef macroName;
++ SourceLineInfo lineInfo;
++ StringRef capturedExpression;
++ ResultDisposition::Flags resultDisposition;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
++
++
++#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
++#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
++
++
++
++#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
++#define CATCH_LAZY_EXPR_HPP_INCLUDED
++
++#include <iosfwd>
++
++namespace Catch {
++
++ class ITransientExpression;
++
++ class LazyExpression {
++ friend class AssertionHandler;
++ friend struct AssertionStats;
++ friend class RunContext;
++
++ ITransientExpression const* m_transientExpression = nullptr;
++ bool m_isNegated;
++ public:
++ LazyExpression( bool isNegated ):
++ m_isNegated(isNegated)
++ {}
++ LazyExpression(LazyExpression const& other) = default;
++ LazyExpression& operator = ( LazyExpression const& ) = delete;
++
++ explicit operator bool() const {
++ return m_transientExpression != nullptr;
++ }
++
++ friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
++ };
++
++} // namespace Catch
++
++#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ struct AssertionResultData
++ {
++ AssertionResultData() = delete;
++
++ AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
++
++ std::string message;
++ mutable std::string reconstructedExpression;
++ LazyExpression lazyExpression;
++ ResultWas::OfType resultType;
++
++ std::string reconstructExpression() const;
++ };
++
++ class AssertionResult {
++ public:
++ AssertionResult() = delete;
++ AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
++
++ bool isOk() const;
++ bool succeeded() const;
++ ResultWas::OfType getResultType() const;
++ bool hasExpression() const;
++ bool hasMessage() const;
++ std::string getExpression() const;
++ std::string getExpressionInMacro() const;
++ bool hasExpandedExpression() const;
++ std::string getExpandedExpression() const;
++ StringRef getMessage() const;
++ SourceLineInfo getSourceInfo() const;
++ StringRef getTestMacroName() const;
++
++ //protected:
++ AssertionInfo m_info;
++ AssertionResultData m_resultData;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
++
++
++#ifndef CATCH_CONFIG_HPP_INCLUDED
++#define CATCH_CONFIG_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
++#define CATCH_TEST_SPEC_HPP_INCLUDED
++
++#ifdef __clang__
++#pragma clang diagnostic push
++#pragma clang diagnostic ignored "-Wpadded"
++#endif
++
++
++
++#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
++#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
++
++
++
++#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
++#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
++
++namespace Catch {
++
++ enum class CaseSensitive { Yes, No };
++
++} // namespace Catch
++
++#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch
++{
++ class WildcardPattern {
++ enum WildcardPosition {
++ NoWildcard = 0,
++ WildcardAtStart = 1,
++ WildcardAtEnd = 2,
++ WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
++ };
++
++ public:
++
++ WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
++ bool matches( std::string const& str ) const;
++
++ private:
++ std::string normaliseString( std::string const& str ) const;
++ CaseSensitive m_caseSensitivity;
++ WildcardPosition m_wildcard = NoWildcard;
++ std::string m_pattern;
++ };
++}
++
++#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
++
++#include <iosfwd>
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ class IConfig;
++ struct TestCaseInfo;
++ class TestCaseHandle;
++
++ class TestSpec {
++
++ class Pattern {
++ public:
++ explicit Pattern( std::string const& name );
++ virtual ~Pattern();
++ virtual bool matches( TestCaseInfo const& testCase ) const = 0;
++ std::string const& name() const;
++ private:
++ virtual void serializeTo( std::ostream& out ) const = 0;
++ // Writes string that would be reparsed into the pattern
++ friend std::ostream& operator<<(std::ostream& out,
++ Pattern const& pattern) {
++ pattern.serializeTo( out );
++ return out;
++ }
++
++ std::string const m_name;
++ };
++
++ class NamePattern : public Pattern {
++ public:
++ explicit NamePattern( std::string const& name, std::string const& filterString );
++ bool matches( TestCaseInfo const& testCase ) const override;
++ private:
++ void serializeTo( std::ostream& out ) const override;
++
++ WildcardPattern m_wildcardPattern;
++ };
++
++ class TagPattern : public Pattern {
++ public:
++ explicit TagPattern( std::string const& tag, std::string const& filterString );
++ bool matches( TestCaseInfo const& testCase ) const override;
++ private:
++ void serializeTo( std::ostream& out ) const override;
++
++ std::string m_tag;
++ };
++
++ struct Filter {
++ std::vector<Detail::unique_ptr<Pattern>> m_required;
++ std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
++
++ //! Serializes this filter into a string that would be parsed into
++ //! an equivalent filter
++ void serializeTo( std::ostream& out ) const;
++ friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
++ f.serializeTo( out );
++ return out;
++ }
++
++ bool matches( TestCaseInfo const& testCase ) const;
++ };
++
++ static std::string extractFilterName( Filter const& filter );
++
++ public:
++ struct FilterMatch {
++ std::string name;
++ std::vector<TestCaseHandle const*> tests;
++ };
++ using Matches = std::vector<FilterMatch>;
++ using vectorStrings = std::vector<std::string>;
++
++ bool hasFilters() const;
++ bool matches( TestCaseInfo const& testCase ) const;
++ Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
++ const vectorStrings & getInvalidSpecs() const;
++
++ private:
++ std::vector<Filter> m_filters;
++ std::vector<std::string> m_invalidSpecs;
++
++ friend class TestSpecParser;
++ //! Serializes this test spec into a string that would be parsed into
++ //! equivalent test spec
++ void serializeTo( std::ostream& out ) const;
++ friend std::ostream& operator<<(std::ostream& out,
++ TestSpec const& spec) {
++ spec.serializeTo( out );
++ return out;
++ }
++ };
++}
++
++#ifdef __clang__
++#pragma clang diagnostic pop
++#endif
++
++#endif // CATCH_TEST_SPEC_HPP_INCLUDED
++
++
++#ifndef CATCH_OPTIONAL_HPP_INCLUDED
++#define CATCH_OPTIONAL_HPP_INCLUDED
++
++
++#include <cassert>
++
++namespace Catch {
++
++ // An optional type
++ template<typename T>
++ class Optional {
++ public:
++ Optional(): nullableValue( nullptr ) {}
++ ~Optional() { reset(); }
++
++ Optional( T const& _value ):
++ nullableValue( new ( storage ) T( _value ) ) {}
++ Optional( T&& _value ):
++ nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
++
++ Optional& operator=( T const& _value ) {
++ reset();
++ nullableValue = new ( storage ) T( _value );
++ return *this;
++ }
++ Optional& operator=( T&& _value ) {
++ reset();
++ nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
++ return *this;
++ }
++
++ Optional( Optional const& _other ):
++ nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
++ Optional( Optional&& _other ):
++ nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
++ : nullptr ) {}
++
++ Optional& operator=( Optional const& _other ) {
++ if ( &_other != this ) {
++ reset();
++ if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
++ }
++ return *this;
++ }
++ Optional& operator=( Optional&& _other ) {
++ if ( &_other != this ) {
++ reset();
++ if ( _other ) {
++ nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
++ }
++ }
++ return *this;
++ }
++
++ void reset() {
++ if ( nullableValue ) { nullableValue->~T(); }
++ nullableValue = nullptr;
++ }
++
++ T& operator*() {
++ assert(nullableValue);
++ return *nullableValue;
++ }
++ T const& operator*() const {
++ assert(nullableValue);
++ return *nullableValue;
++ }
++ T* operator->() {
++ assert(nullableValue);
++ return nullableValue;
++ }
++ const T* operator->() const {
++ assert(nullableValue);
++ return nullableValue;
++ }
++
++ T valueOr( T const& defaultValue ) const {
++ return nullableValue ? *nullableValue : defaultValue;
++ }
++
++ bool some() const { return nullableValue != nullptr; }
++ bool none() const { return nullableValue == nullptr; }
++
++ bool operator !() const { return nullableValue == nullptr; }
++ explicit operator bool() const {
++ return some();
++ }
++
++ friend bool operator==(Optional const& a, Optional const& b) {
++ if (a.none() && b.none()) {
++ return true;
++ } else if (a.some() && b.some()) {
++ return *a == *b;
++ } else {
++ return false;
++ }
++ }
++ friend bool operator!=(Optional const& a, Optional const& b) {
++ return !( a == b );
++ }
++
++ private:
++ T* nullableValue;
++ alignas(alignof(T)) char storage[sizeof(T)];
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_OPTIONAL_HPP_INCLUDED
++
++
++#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
++#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++
++ enum class GenerateFrom {
++ Time,
++ RandomDevice,
++ //! Currently equivalent to RandomDevice, but can change at any point
++ Default
++ };
++
++ std::uint32_t generateRandomSeed(GenerateFrom from);
++
++} // end namespace Catch
++
++#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
++#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
++
++
++#include <map>
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ enum class ColourMode : std::uint8_t;
++
++ namespace Detail {
++ //! Splits the reporter spec into reporter name and kv-pair options
++ std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
++
++ Optional<ColourMode> stringToColourMode( StringRef colourMode );
++ }
++
++ /**
++ * Structured reporter spec that a reporter can be created from
++ *
++ * Parsing has been validated, but semantics have not. This means e.g.
++ * that the colour mode is known to Catch2, but it might not be
++ * compiled into the binary, and the output filename might not be
++ * openable.
++ */
++ class ReporterSpec {
++ std::string m_name;
++ Optional<std::string> m_outputFileName;
++ Optional<ColourMode> m_colourMode;
++ std::map<std::string, std::string> m_customOptions;
++
++ friend bool operator==( ReporterSpec const& lhs,
++ ReporterSpec const& rhs );
++ friend bool operator!=( ReporterSpec const& lhs,
++ ReporterSpec const& rhs ) {
++ return !( lhs == rhs );
++ }
++
++ public:
++ ReporterSpec(
++ std::string name,
++ Optional<std::string> outputFileName,
++ Optional<ColourMode> colourMode,
++ std::map<std::string, std::string> customOptions );
++
++ std::string const& name() const { return m_name; }
++
++ Optional<std::string> const& outputFile() const {
++ return m_outputFileName;
++ }
++
++ Optional<ColourMode> const& colourMode() const { return m_colourMode; }
++
++ std::map<std::string, std::string> const& customOptions() const {
++ return m_customOptions;
++ }
++ };
++
++ /**
++ * Parses provided reporter spec string into
++ *
++ * Returns empty optional on errors, e.g.
++ * * field that is not first and not a key+value pair
++ * * duplicated keys in kv pair
++ * * unknown catch reporter option
++ * * empty key/value in an custom kv pair
++ * * ...
++ */
++ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
++
++}
++
++#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
++
++#include <chrono>
++#include <map>
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ class IStream;
++
++ /**
++ * `ReporterSpec` but with the defaults filled in.
++ *
++ * Like `ReporterSpec`, the semantics are unchecked.
++ */
++ struct ProcessedReporterSpec {
++ std::string name;
++ std::string outputFilename;
++ ColourMode colourMode;
++ std::map<std::string, std::string> customOptions;
++ friend bool operator==( ProcessedReporterSpec const& lhs,
++ ProcessedReporterSpec const& rhs );
++ friend bool operator!=( ProcessedReporterSpec const& lhs,
++ ProcessedReporterSpec const& rhs ) {
++ return !( lhs == rhs );
++ }
++ };
++
++ struct ConfigData {
++
++ bool listTests = false;
++ bool listTags = false;
++ bool listReporters = false;
++ bool listListeners = false;
++
++ bool showSuccessfulTests = false;
++ bool shouldDebugBreak = false;
++ bool noThrow = false;
++ bool showHelp = false;
++ bool showInvisibles = false;
++ bool filenamesAsTags = false;
++ bool libIdentify = false;
++ bool allowZeroTests = false;
++
++ int abortAfter = -1;
++ uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
++
++ unsigned int shardCount = 1;
++ unsigned int shardIndex = 0;
++
++ bool skipBenchmarks = false;
++ bool benchmarkNoAnalysis = false;
++ unsigned int benchmarkSamples = 100;
++ double benchmarkConfidenceInterval = 0.95;
++ unsigned int benchmarkResamples = 100'000;
++ std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
++
++ Verbosity verbosity = Verbosity::Normal;
++ WarnAbout::What warnings = WarnAbout::Nothing;
++ ShowDurations showDurations = ShowDurations::DefaultForReporter;
++ double minDuration = -1;
++ TestRunOrder runOrder = TestRunOrder::Declared;
++ ColourMode defaultColourMode = ColourMode::PlatformDefault;
++ WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
++
++ std::string defaultOutputFilename;
++ std::string name;
++ std::string processName;
++ std::vector<ReporterSpec> reporterSpecifications;
++
++ std::vector<std::string> testsOrTags;
++ std::vector<std::string> sectionsToRun;
++ };
++
++
++ class Config : public IConfig {
++ public:
++
++ Config() = default;
++ Config( ConfigData const& data );
++ ~Config() override; // = default in the cpp file
++
++ bool listTests() const;
++ bool listTags() const;
++ bool listReporters() const;
++ bool listListeners() const;
++
++ std::vector<ReporterSpec> const& getReporterSpecs() const;
++ std::vector<ProcessedReporterSpec> const&
++ getProcessedReporterSpecs() const;
++
++ std::vector<std::string> const& getTestsOrTags() const override;
++ std::vector<std::string> const& getSectionsToRun() const override;
++
++ TestSpec const& testSpec() const override;
++ bool hasTestFilters() const override;
++
++ bool showHelp() const;
++
++ // IConfig interface
++ bool allowThrows() const override;
++ StringRef name() const override;
++ bool includeSuccessfulResults() const override;
++ bool warnAboutMissingAssertions() const override;
++ bool warnAboutUnmatchedTestSpecs() const override;
++ bool zeroTestsCountAsSuccess() const override;
++ ShowDurations showDurations() const override;
++ double minDuration() const override;
++ TestRunOrder runOrder() const override;
++ uint32_t rngSeed() const override;
++ unsigned int shardCount() const override;
++ unsigned int shardIndex() const override;
++ ColourMode defaultColourMode() const override;
++ bool shouldDebugBreak() const override;
++ int abortAfter() const override;
++ bool showInvisibles() const override;
++ Verbosity verbosity() const override;
++ bool skipBenchmarks() const override;
++ bool benchmarkNoAnalysis() const override;
++ unsigned int benchmarkSamples() const override;
++ double benchmarkConfidenceInterval() const override;
++ unsigned int benchmarkResamples() const override;
++ std::chrono::milliseconds benchmarkWarmupTime() const override;
++
++ private:
++ // Reads Bazel env vars and applies them to the config
++ void readBazelEnvVars();
++
++ ConfigData m_data;
++ std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
++ TestSpec m_testSpec;
++ bool m_hasTestFilters = false;
++ };
++} // end namespace Catch
++
++#endif // CATCH_CONFIG_HPP_INCLUDED
++
++
++#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
++#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++ //! Returns Catch2's current RNG seed.
++ std::uint32_t getSeed();
++}
++
++#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
++
++
++#ifndef CATCH_MESSAGE_HPP_INCLUDED
++#define CATCH_MESSAGE_HPP_INCLUDED
++
++
++
++
++/** \file
++ * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
++ *
++ * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
++ * by prepending CATCH_. This may not be desirable if the only clashes are with
++ * logger macros such as INFO and WARN. In this cases
++ * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
++ * of relevant macros.
++ *
++ */
++
++#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
++#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
++
++
++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
++ #define CATCH_CONFIG_PREFIX_MESSAGES
++#endif
++
++#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
++
++
++#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
++#define CATCH_STREAM_END_STOP_HPP_INCLUDED
++
++
++namespace Catch {
++
++ // Use this in variadic streaming macros to allow
++ // << +StreamEndStop
++ // as well as
++ // << stuff +StreamEndStop
++ struct StreamEndStop {
++ constexpr StringRef operator+() const { return StringRef(); }
++
++ template <typename T>
++ constexpr friend T const& operator+( T const& value, StreamEndStop ) {
++ return value;
++ }
++ };
++
++} // namespace Catch
++
++#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
++
++
++#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
++#define CATCH_MESSAGE_INFO_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ struct MessageInfo {
++ MessageInfo( StringRef _macroName,
++ SourceLineInfo const& _lineInfo,
++ ResultWas::OfType _type );
++
++ StringRef macroName;
++ std::string message;
++ SourceLineInfo lineInfo;
++ ResultWas::OfType type;
++ unsigned int sequence;
++
++ bool operator == (MessageInfo const& other) const {
++ return sequence == other.sequence;
++ }
++ bool operator < (MessageInfo const& other) const {
++ return sequence < other.sequence;
++ }
++ private:
++ static unsigned int globalCount;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ struct SourceLineInfo;
++ class IResultCapture;
++
++ struct MessageStream {
++
++ template<typename T>
++ MessageStream& operator << ( T const& value ) {
++ m_stream << value;
++ return *this;
++ }
++
++ ReusableStringStream m_stream;
++ };
++
++ struct MessageBuilder : MessageStream {
++ MessageBuilder( StringRef macroName,
++ SourceLineInfo const& lineInfo,
++ ResultWas::OfType type ):
++ m_info(macroName, lineInfo, type) {}
++
++ template<typename T>
++ MessageBuilder&& operator << ( T const& value ) && {
++ m_stream << value;
++ return CATCH_MOVE(*this);
++ }
++
++ MessageInfo m_info;
++ };
++
++ class ScopedMessage {
++ public:
++ explicit ScopedMessage( MessageBuilder&& builder );
++ ScopedMessage( ScopedMessage& duplicate ) = delete;
++ ScopedMessage( ScopedMessage&& old ) noexcept;
++ ~ScopedMessage();
++
++ MessageInfo m_info;
++ bool m_moved = false;
++ };
++
++ class Capturer {
++ std::vector<MessageInfo> m_messages;
++ IResultCapture& m_resultCapture;
++ size_t m_captured = 0;
++ public:
++ Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
++
++ Capturer(Capturer const&) = delete;
++ Capturer& operator=(Capturer const&) = delete;
++
++ ~Capturer();
++
++ void captureValue( size_t index, std::string const& value );
++
++ template<typename T>
++ void captureValues( size_t index, T const& value ) {
++ captureValue( index, Catch::Detail::stringify( value ) );
++ }
++
++ template<typename T, typename... Ts>
++ void captureValues( size_t index, T const& value, Ts const&... values ) {
++ captureValue( index, Catch::Detail::stringify(value) );
++ captureValues( index+1, values... );
++ }
++ };
++
++} // end namespace Catch
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
++ catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
++ Catch::Capturer varName( macroName##_catch_sr, \
++ CATCH_INTERNAL_LINEINFO, \
++ Catch::ResultWas::Info, \
++ #__VA_ARGS__##_catch_sr ); \
++ varName.captureValues( 0, __VA_ARGS__ )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_INFO( macroName, log ) \
++ const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
++ Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
++
++
++#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
++
++ #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
++ #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
++ #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
++ #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
++
++#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
++
++ #define CATCH_INFO( msg ) (void)(0)
++ #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
++ #define CATCH_WARN( msg ) (void)(0)
++ #define CATCH_CAPTURE( ... ) (void)(0)
++
++#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
++
++ #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
++ #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
++ #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
++ #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
++
++#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
++
++ #define INFO( msg ) (void)(0)
++ #define UNSCOPED_INFO( msg ) (void)(0)
++ #define WARN( msg ) (void)(0)
++ #define CAPTURE( ... ) (void)(0)
++
++#endif // end of user facing macro declarations
++
++
++
++
++#endif // CATCH_MESSAGE_HPP_INCLUDED
++
++
++#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
++#define CATCH_SECTION_INFO_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TOTALS_HPP_INCLUDED
++#define CATCH_TOTALS_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++
++ struct Counts {
++ Counts operator - ( Counts const& other ) const;
++ Counts& operator += ( Counts const& other );
++
++ std::uint64_t total() const;
++ bool allPassed() const;
++ bool allOk() const;
++
++ std::uint64_t passed = 0;
++ std::uint64_t failed = 0;
++ std::uint64_t failedButOk = 0;
++ std::uint64_t skipped = 0;
++ };
++
++ struct Totals {
++
++ Totals operator - ( Totals const& other ) const;
++ Totals& operator += ( Totals const& other );
++
++ Totals delta( Totals const& prevTotals ) const;
++
++ Counts assertions;
++ Counts testCases;
++ };
++}
++
++#endif // CATCH_TOTALS_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ struct SectionInfo {
++ // The last argument is ignored, so that people can write
++ // SECTION("ShortName", "Proper description that is long") and
++ // still use the `-c` flag comfortably.
++ SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
++ const char* const = nullptr ):
++ name(CATCH_MOVE(_name)),
++ lineInfo(_lineInfo)
++ {}
++
++ std::string name;
++ SourceLineInfo lineInfo;
++ };
++
++ struct SectionEndInfo {
++ SectionInfo sectionInfo;
++ Counts prevAssertions;
++ double durationInSeconds;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_SECTION_INFO_HPP_INCLUDED
++
++
++#ifndef CATCH_SESSION_HPP_INCLUDED
++#define CATCH_SESSION_HPP_INCLUDED
++
++
++
++#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
++#define CATCH_COMMANDLINE_HPP_INCLUDED
++
++
++
++#ifndef CATCH_CLARA_HPP_INCLUDED
++#define CATCH_CLARA_HPP_INCLUDED
++
++#if defined( __clang__ )
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wweak-vtables"
++# pragma clang diagnostic ignored "-Wshadow"
++# pragma clang diagnostic ignored "-Wdeprecated"
++#endif
++
++#if defined( __GNUC__ )
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wsign-conversion"
++#endif
++
++#ifndef CLARA_CONFIG_OPTIONAL_TYPE
++# ifdef __has_include
++# if __has_include( <optional>) && __cplusplus >= 201703L
++# include <optional>
++# define CLARA_CONFIG_OPTIONAL_TYPE std::optional
++# endif
++# endif
++#endif
++
++
++#include <cassert>
++#include <memory>
++#include <ostream>
++#include <sstream>
++#include <string>
++#include <type_traits>
++#include <vector>
++
++namespace Catch {
++ namespace Clara {
++
++ class Args;
++ class Parser;
++
++ // enum of result types from a parse
++ enum class ParseResultType {
++ Matched,
++ NoMatch,
++ ShortCircuitAll,
++ ShortCircuitSame
++ };
++
++ struct accept_many_t {};
++ constexpr accept_many_t accept_many {};
++
++ namespace Detail {
++ struct fake_arg {
++ template <typename T>
++ operator T();
++ };
++
++ template <typename F, typename = void>
++ struct is_unary_function : std::false_type {};
++
++ template <typename F>
++ struct is_unary_function<
++ F,
++ Catch::Detail::void_t<decltype(
++ std::declval<F>()( fake_arg() ) )
++ >
++ > : std::true_type {};
++
++ // Traits for extracting arg and return type of lambdas (for single
++ // argument lambdas)
++ template <typename L>
++ struct UnaryLambdaTraits
++ : UnaryLambdaTraits<decltype( &L::operator() )> {};
++
++ template <typename ClassT, typename ReturnT, typename... Args>
++ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
++ static const bool isValid = false;
++ };
++
++ template <typename ClassT, typename ReturnT, typename ArgT>
++ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
++ static const bool isValid = true;
++ using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
++ using ReturnType = ReturnT;
++ };
++
++ class TokenStream;
++
++ // Wraps a token coming from a token stream. These may not directly
++ // correspond to strings as a single string may encode an option +
++ // its argument if the : or = form is used
++ enum class TokenType { Option, Argument };
++ struct Token {
++ TokenType type;
++ StringRef token;
++ };
++
++ // Abstracts iterators into args as a stream of tokens, with option
++ // arguments uniformly handled
++ class TokenStream {
++ using Iterator = std::vector<StringRef>::const_iterator;
++ Iterator it;
++ Iterator itEnd;
++ std::vector<Token> m_tokenBuffer;
++ void loadBuffer();
++
++ public:
++ explicit TokenStream( Args const& args );
++ TokenStream( Iterator it, Iterator itEnd );
++
++ explicit operator bool() const {
++ return !m_tokenBuffer.empty() || it != itEnd;
++ }
++
++ size_t count() const {
++ return m_tokenBuffer.size() + ( itEnd - it );
++ }
++
++ Token operator*() const {
++ assert( !m_tokenBuffer.empty() );
++ return m_tokenBuffer.front();
++ }
++
++ Token const* operator->() const {
++ assert( !m_tokenBuffer.empty() );
++ return &m_tokenBuffer.front();
++ }
++
++ TokenStream& operator++();
++ };
++
++ //! Denotes type of a parsing result
++ enum class ResultType {
++ Ok, ///< No errors
++ LogicError, ///< Error in user-specified arguments for
++ ///< construction
++ RuntimeError ///< Error in parsing inputs
++ };
++
++ class ResultBase {
++ protected:
++ ResultBase( ResultType type ): m_type( type ) {}
++ virtual ~ResultBase(); // = default;
++
++
++ ResultBase(ResultBase const&) = default;
++ ResultBase& operator=(ResultBase const&) = default;
++ ResultBase(ResultBase&&) = default;
++ ResultBase& operator=(ResultBase&&) = default;
++
++ virtual void enforceOk() const = 0;
++
++ ResultType m_type;
++ };
++
++ template <typename T>
++ class ResultValueBase : public ResultBase {
++ public:
++ T const& value() const& {
++ enforceOk();
++ return m_value;
++ }
++ T&& value() && {
++ enforceOk();
++ return CATCH_MOVE( m_value );
++ }
++
++ protected:
++ ResultValueBase( ResultType type ): ResultBase( type ) {}
++
++ ResultValueBase( ResultValueBase const& other ):
++ ResultBase( other ) {
++ if ( m_type == ResultType::Ok )
++ new ( &m_value ) T( other.m_value );
++ }
++ ResultValueBase( ResultValueBase&& other ):
++ ResultBase( other ) {
++ if ( m_type == ResultType::Ok )
++ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
++ }
++
++
++ ResultValueBase( ResultType, T const& value ):
++ ResultBase( ResultType::Ok ) {
++ new ( &m_value ) T( value );
++ }
++ ResultValueBase( ResultType, T&& value ):
++ ResultBase( ResultType::Ok ) {
++ new ( &m_value ) T( CATCH_MOVE(value) );
++ }
++
++ ResultValueBase& operator=( ResultValueBase const& other ) {
++ if ( m_type == ResultType::Ok )
++ m_value.~T();
++ ResultBase::operator=( other );
++ if ( m_type == ResultType::Ok )
++ new ( &m_value ) T( other.m_value );
++ return *this;
++ }
++ ResultValueBase& operator=( ResultValueBase&& other ) {
++ if ( m_type == ResultType::Ok ) m_value.~T();
++ ResultBase::operator=( other );
++ if ( m_type == ResultType::Ok )
++ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
++ return *this;
++ }
++
++
++ ~ResultValueBase() override {
++ if ( m_type == ResultType::Ok )
++ m_value.~T();
++ }
++
++ union {
++ T m_value;
++ };
++ };
++
++ template <> class ResultValueBase<void> : public ResultBase {
++ protected:
++ using ResultBase::ResultBase;
++ };
++
++ template <typename T = void>
++ class BasicResult : public ResultValueBase<T> {
++ public:
++ template <typename U>
++ explicit BasicResult( BasicResult<U> const& other ):
++ ResultValueBase<T>( other.type() ),
++ m_errorMessage( other.errorMessage() ) {
++ assert( type() != ResultType::Ok );
++ }
++
++ template <typename U>
++ static auto ok( U&& value ) -> BasicResult {
++ return { ResultType::Ok, CATCH_FORWARD(value) };
++ }
++ static auto ok() -> BasicResult { return { ResultType::Ok }; }
++ static auto logicError( std::string&& message )
++ -> BasicResult {
++ return { ResultType::LogicError, CATCH_MOVE(message) };
++ }
++ static auto runtimeError( std::string&& message )
++ -> BasicResult {
++ return { ResultType::RuntimeError, CATCH_MOVE(message) };
++ }
++
++ explicit operator bool() const {
++ return m_type == ResultType::Ok;
++ }
++ auto type() const -> ResultType { return m_type; }
++ auto errorMessage() const -> std::string const& {
++ return m_errorMessage;
++ }
++
++ protected:
++ void enforceOk() const override {
++
++ // Errors shouldn't reach this point, but if they do
++ // the actual error message will be in m_errorMessage
++ assert( m_type != ResultType::LogicError );
++ assert( m_type != ResultType::RuntimeError );
++ if ( m_type != ResultType::Ok )
++ std::abort();
++ }
++
++ std::string
++ m_errorMessage; // Only populated if resultType is an error
++
++ BasicResult( ResultType type,
++ std::string&& message ):
++ ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
++ assert( m_type != ResultType::Ok );
++ }
++
++ using ResultValueBase<T>::ResultValueBase;
++ using ResultBase::m_type;
++ };
++
++ class ParseState {
++ public:
++ ParseState( ParseResultType type,
++ TokenStream remainingTokens );
++
++ ParseResultType type() const { return m_type; }
++ TokenStream const& remainingTokens() const& {
++ return m_remainingTokens;
++ }
++ TokenStream&& remainingTokens() && {
++ return CATCH_MOVE( m_remainingTokens );
++ }
++
++ private:
++ ParseResultType m_type;
++ TokenStream m_remainingTokens;
++ };
++
++ using Result = BasicResult<void>;
++ using ParserResult = BasicResult<ParseResultType>;
++ using InternalParseResult = BasicResult<ParseState>;
++
++ struct HelpColumns {
++ std::string left;
++ StringRef descriptions;
++ };
++
++ template <typename T>
++ ParserResult convertInto( std::string const& source, T& target ) {
++ std::stringstream ss( source );
++ ss >> target;
++ if ( ss.fail() ) {
++ return ParserResult::runtimeError(
++ "Unable to convert '" + source +
++ "' to destination type" );
++ } else {
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++ }
++ ParserResult convertInto( std::string const& source,
++ std::string& target );
++ ParserResult convertInto( std::string const& source, bool& target );
++
++#ifdef CLARA_CONFIG_OPTIONAL_TYPE
++ template <typename T>
++ auto convertInto( std::string const& source,
++ CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
++ -> ParserResult {
++ T temp;
++ auto result = convertInto( source, temp );
++ if ( result )
++ target = CATCH_MOVE( temp );
++ return result;
++ }
++#endif // CLARA_CONFIG_OPTIONAL_TYPE
++
++ struct BoundRef : Catch::Detail::NonCopyable {
++ virtual ~BoundRef() = default;
++ virtual bool isContainer() const;
++ virtual bool isFlag() const;
++ };
++ struct BoundValueRefBase : BoundRef {
++ virtual auto setValue( std::string const& arg )
++ -> ParserResult = 0;
++ };
++ struct BoundFlagRefBase : BoundRef {
++ virtual auto setFlag( bool flag ) -> ParserResult = 0;
++ bool isFlag() const override;
++ };
++
++ template <typename T> struct BoundValueRef : BoundValueRefBase {
++ T& m_ref;
++
++ explicit BoundValueRef( T& ref ): m_ref( ref ) {}
++
++ ParserResult setValue( std::string const& arg ) override {
++ return convertInto( arg, m_ref );
++ }
++ };
++
++ template <typename T>
++ struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
++ std::vector<T>& m_ref;
++
++ explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}
++
++ auto isContainer() const -> bool override { return true; }
++
++ auto setValue( std::string const& arg )
++ -> ParserResult override {
++ T temp;
++ auto result = convertInto( arg, temp );
++ if ( result )
++ m_ref.push_back( temp );
++ return result;
++ }
++ };
++
++ struct BoundFlagRef : BoundFlagRefBase {
++ bool& m_ref;
++
++ explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}
++
++ ParserResult setFlag( bool flag ) override;
++ };
++
++ template <typename ReturnType> struct LambdaInvoker {
++ static_assert(
++ std::is_same<ReturnType, ParserResult>::value,
++ "Lambda must return void or clara::ParserResult" );
++
++ template <typename L, typename ArgType>
++ static auto invoke( L const& lambda, ArgType const& arg )
++ -> ParserResult {
++ return lambda( arg );
++ }
++ };
++
++ template <> struct LambdaInvoker<void> {
++ template <typename L, typename ArgType>
++ static auto invoke( L const& lambda, ArgType const& arg )
++ -> ParserResult {
++ lambda( arg );
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++ };
++
++ template <typename ArgType, typename L>
++ auto invokeLambda( L const& lambda, std::string const& arg )
++ -> ParserResult {
++ ArgType temp{};
++ auto result = convertInto( arg, temp );
++ return !result ? result
++ : LambdaInvoker<typename UnaryLambdaTraits<
++ L>::ReturnType>::invoke( lambda, temp );
++ }
++
++ template <typename L> struct BoundLambda : BoundValueRefBase {
++ L m_lambda;
++
++ static_assert(
++ UnaryLambdaTraits<L>::isValid,
++ "Supplied lambda must take exactly one argument" );
++ explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}
++
++ auto setValue( std::string const& arg )
++ -> ParserResult override {
++ return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
++ m_lambda, arg );
++ }
++ };
++
++ template <typename L> struct BoundManyLambda : BoundLambda<L> {
++ explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
++ bool isContainer() const override { return true; }
++ };
++
++ template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
++ L m_lambda;
++
++ static_assert(
++ UnaryLambdaTraits<L>::isValid,
++ "Supplied lambda must take exactly one argument" );
++ static_assert(
++ std::is_same<typename UnaryLambdaTraits<L>::ArgType,
++ bool>::value,
++ "flags must be boolean" );
++
++ explicit BoundFlagLambda( L const& lambda ):
++ m_lambda( lambda ) {}
++
++ auto setFlag( bool flag ) -> ParserResult override {
++ return LambdaInvoker<typename UnaryLambdaTraits<
++ L>::ReturnType>::invoke( m_lambda, flag );
++ }
++ };
++
++ enum class Optionality { Optional, Required };
++
++ class ParserBase {
++ public:
++ virtual ~ParserBase() = default;
++ virtual auto validate() const -> Result { return Result::ok(); }
++ virtual auto parse( std::string const& exeName,
++ TokenStream tokens ) const
++ -> InternalParseResult = 0;
++ virtual size_t cardinality() const;
++
++ InternalParseResult parse( Args const& args ) const;
++ };
++
++ template <typename DerivedT>
++ class ComposableParserImpl : public ParserBase {
++ public:
++ template <typename T>
++ auto operator|( T const& other ) const -> Parser;
++ };
++
++ // Common code and state for Args and Opts
++ template <typename DerivedT>
++ class ParserRefImpl : public ComposableParserImpl<DerivedT> {
++ protected:
++ Optionality m_optionality = Optionality::Optional;
++ std::shared_ptr<BoundRef> m_ref;
++ StringRef m_hint;
++ StringRef m_description;
++
++ explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
++ m_ref( ref ) {}
++
++ public:
++ template <typename LambdaT>
++ ParserRefImpl( accept_many_t,
++ LambdaT const& ref,
++ StringRef hint ):
++ m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
++ m_hint( hint ) {}
++
++ template <typename T,
++ typename = typename std::enable_if_t<
++ !Detail::is_unary_function<T>::value>>
++ ParserRefImpl( T& ref, StringRef hint ):
++ m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
++ m_hint( hint ) {}
++
++ template <typename LambdaT,
++ typename = typename std::enable_if_t<
++ Detail::is_unary_function<LambdaT>::value>>
++ ParserRefImpl( LambdaT const& ref, StringRef hint ):
++ m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
++ m_hint( hint ) {}
++
++ DerivedT& operator()( StringRef description ) & {
++ m_description = description;
++ return static_cast<DerivedT&>( *this );
++ }
++ DerivedT&& operator()( StringRef description ) && {
++ m_description = description;
++ return static_cast<DerivedT&&>( *this );
++ }
++
++ auto optional() -> DerivedT& {
++ m_optionality = Optionality::Optional;
++ return static_cast<DerivedT&>( *this );
++ }
++
++ auto required() -> DerivedT& {
++ m_optionality = Optionality::Required;
++ return static_cast<DerivedT&>( *this );
++ }
++
++ auto isOptional() const -> bool {
++ return m_optionality == Optionality::Optional;
++ }
++
++ auto cardinality() const -> size_t override {
++ if ( m_ref->isContainer() )
++ return 0;
++ else
++ return 1;
++ }
++
++ StringRef hint() const { return m_hint; }
++ };
++
++ } // namespace detail
++
++
++ // A parser for arguments
++ class Arg : public Detail::ParserRefImpl<Arg> {
++ public:
++ using ParserRefImpl::ParserRefImpl;
++ using ParserBase::parse;
++
++ Detail::InternalParseResult
++ parse(std::string const&,
++ Detail::TokenStream tokens) const override;
++ };
++
++ // A parser for options
++ class Opt : public Detail::ParserRefImpl<Opt> {
++ protected:
++ std::vector<StringRef> m_optNames;
++
++ public:
++ template <typename LambdaT>
++ explicit Opt(LambdaT const& ref) :
++ ParserRefImpl(
++ std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
++
++ explicit Opt(bool& ref);
++
++ template <typename LambdaT,
++ typename = typename std::enable_if_t<
++ Detail::is_unary_function<LambdaT>::value>>
++ Opt( LambdaT const& ref, StringRef hint ):
++ ParserRefImpl( ref, hint ) {}
++
++ template <typename LambdaT>
++ Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
++ ParserRefImpl( accept_many, ref, hint ) {}
++
++ template <typename T,
++ typename = typename std::enable_if_t<
++ !Detail::is_unary_function<T>::value>>
++ Opt( T& ref, StringRef hint ):
++ ParserRefImpl( ref, hint ) {}
++
++ Opt& operator[]( StringRef optName ) & {
++ m_optNames.push_back(optName);
++ return *this;
++ }
++ Opt&& operator[]( StringRef optName ) && {
++ m_optNames.push_back( optName );
++ return CATCH_MOVE(*this);
++ }
++
++ Detail::HelpColumns getHelpColumns() const;
++
++ bool isMatch(StringRef optToken) const;
++
++ using ParserBase::parse;
++
++ Detail::InternalParseResult
++ parse(std::string const&,
++ Detail::TokenStream tokens) const override;
++
++ Detail::Result validate() const override;
++ };
++
++ // Specifies the name of the executable
++ class ExeName : public Detail::ComposableParserImpl<ExeName> {
++ std::shared_ptr<std::string> m_name;
++ std::shared_ptr<Detail::BoundValueRefBase> m_ref;
++
++ public:
++ ExeName();
++ explicit ExeName(std::string& ref);
++
++ template <typename LambdaT>
++ explicit ExeName(LambdaT const& lambda) : ExeName() {
++ m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
++ }
++
++ // The exe name is not parsed out of the normal tokens, but is
++ // handled specially
++ Detail::InternalParseResult
++ parse(std::string const&,
++ Detail::TokenStream tokens) const override;
++
++ std::string const& name() const { return *m_name; }
++ Detail::ParserResult set(std::string const& newName);
++ };
++
++
++ // A Combined parser
++ class Parser : Detail::ParserBase {
++ mutable ExeName m_exeName;
++ std::vector<Opt> m_options;
++ std::vector<Arg> m_args;
++
++ public:
++
++ auto operator|=(ExeName const& exeName) -> Parser& {
++ m_exeName = exeName;
++ return *this;
++ }
++
++ auto operator|=(Arg const& arg) -> Parser& {
++ m_args.push_back(arg);
++ return *this;
++ }
++
++ friend Parser& operator|=( Parser& p, Opt const& opt ) {
++ p.m_options.push_back( opt );
++ return p;
++ }
++ friend Parser& operator|=( Parser& p, Opt&& opt ) {
++ p.m_options.push_back( CATCH_MOVE(opt) );
++ return p;
++ }
++
++ Parser& operator|=(Parser const& other);
++
++ template <typename T>
++ friend Parser operator|( Parser const& p, T&& rhs ) {
++ Parser temp( p );
++ temp |= rhs;
++ return temp;
++ }
++
++ template <typename T>
++ friend Parser operator|( Parser&& p, T&& rhs ) {
++ p |= CATCH_FORWARD(rhs);
++ return CATCH_MOVE(p);
++ }
++
++ std::vector<Detail::HelpColumns> getHelpColumns() const;
++
++ void writeToStream(std::ostream& os) const;
++
++ friend auto operator<<(std::ostream& os, Parser const& parser)
++ -> std::ostream& {
++ parser.writeToStream(os);
++ return os;
++ }
++
++ Detail::Result validate() const override;
++
++ using ParserBase::parse;
++ Detail::InternalParseResult
++ parse(std::string const& exeName,
++ Detail::TokenStream tokens) const override;
++ };
++
++ /**
++ * Wrapper over argc + argv, assumes that the inputs outlive it
++ */
++ class Args {
++ friend Detail::TokenStream;
++ StringRef m_exeName;
++ std::vector<StringRef> m_args;
++
++ public:
++ Args(int argc, char const* const* argv);
++ // Helper constructor for testing
++ Args(std::initializer_list<StringRef> args);
++
++ StringRef exeName() const { return m_exeName; }
++ };
++
++
++ // Convenience wrapper for option parser that specifies the help option
++ struct Help : Opt {
++ Help(bool& showHelpFlag);
++ };
++
++ // Result type for parser operation
++ using Detail::ParserResult;
++
++ namespace Detail {
++ template <typename DerivedT>
++ template <typename T>
++ Parser
++ ComposableParserImpl<DerivedT>::operator|(T const& other) const {
++ return Parser() | static_cast<DerivedT const&>(*this) | other;
++ }
++ }
++
++ } // namespace Clara
++} // namespace Catch
++
++#if defined( __clang__ )
++# pragma clang diagnostic pop
++#endif
++
++#if defined( __GNUC__ )
++# pragma GCC diagnostic pop
++#endif
++
++#endif // CATCH_CLARA_HPP_INCLUDED
++
++namespace Catch {
++
++ struct ConfigData;
++
++ Clara::Parser makeCommandLineParser( ConfigData& config );
++
++} // end namespace Catch
++
++#endif // CATCH_COMMANDLINE_HPP_INCLUDED
++
++namespace Catch {
++
++ class Session : Detail::NonCopyable {
++ public:
++
++ Session();
++ ~Session();
++
++ void showHelp() const;
++ void libIdentify();
++
++ int applyCommandLine( int argc, char const * const * argv );
++ #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
++ int applyCommandLine( int argc, wchar_t const * const * argv );
++ #endif
++
++ void useConfigData( ConfigData const& configData );
++
++ template<typename CharT>
++ int run(int argc, CharT const * const argv[]) {
++ if (m_startupExceptions)
++ return 1;
++ int returnCode = applyCommandLine(argc, argv);
++ if (returnCode == 0)
++ returnCode = run();
++ return returnCode;
++ }
++
++ int run();
++
++ Clara::Parser const& cli() const;
++ void cli( Clara::Parser const& newParser );
++ ConfigData& configData();
++ Config& config();
++ private:
++ int runInternal();
++
++ Clara::Parser m_cli;
++ ConfigData m_configData;
++ Detail::unique_ptr<Config> m_config;
++ bool m_startupExceptions = false;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_SESSION_HPP_INCLUDED
++
++
++#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
++#define CATCH_TAG_ALIAS_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ struct TagAlias {
++ TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
++ tag(_tag),
++ lineInfo(_lineInfo)
++ {}
++
++ std::string tag;
++ SourceLineInfo lineInfo;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
++
++
++#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
++#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
++
++
++namespace Catch {
++
++ struct RegistrarForTagAliases {
++ RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
++ };
++
++} // end namespace Catch
++
++#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
++
++
++#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
++#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
++
++// We need this suppression to leak, because it took until GCC 10
++// for the front end to handle local suppression via _Pragma properly
++// inside templates (so `TEMPLATE_TEST_CASE` and co).
++// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++
++
++
++#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
++#define CATCH_TEST_MACROS_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
++#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
++
++
++
++#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
++#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
++
++
++
++#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
++#define CATCH_DECOMPOSER_HPP_INCLUDED
++
++
++
++#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
++#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
++
++
++#include <type_traits>
++
++namespace Catch {
++ namespace Detail {
++
++#if defined( __GNUC__ ) && !defined( __clang__ )
++# pragma GCC diagnostic push
++ // GCC likes to complain about comparing bool with 0, in the decltype()
++ // that defines the comparable traits below.
++# pragma GCC diagnostic ignored "-Wbool-compare"
++ // "ordered comparison of pointer with integer zero" same as above,
++ // but it does not have a separate warning flag to suppress
++# pragma GCC diagnostic ignored "-Wextra"
++ // Did you know that comparing floats with `0` directly
++ // is super-duper dangerous in unevaluated context?
++# pragma GCC diagnostic ignored "-Wfloat-equal"
++#endif
++
++#if defined( __clang__ )
++# pragma clang diagnostic push
++ // Did you know that comparing floats with `0` directly
++ // is super-duper dangerous in unevaluated context?
++# pragma clang diagnostic ignored "-Wfloat-equal"
++#endif
++
++#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \
++ template <typename, typename, typename = void> \
++ struct is_##id##_comparable : std::false_type {}; \
++ template <typename T, typename U> \
++ struct is_##id##_comparable< \
++ T, \
++ U, \
++ void_t<decltype( std::declval<T>() op std::declval<U>() )>> \
++ : std::true_type {}; \
++ template <typename, typename = void> \
++ struct is_##id##_0_comparable : std::false_type {}; \
++ template <typename T> \
++ struct is_##id##_0_comparable<T, \
++ void_t<decltype( std::declval<T>() op 0 )>> \
++ : std::true_type {};
++
++ // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
++ CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
++ CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
++ CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
++ CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
++ CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
++ CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
++
++#undef CATCH_DEFINE_COMPARABLE_TRAIT
++
++#if defined( __GNUC__ ) && !defined( __clang__ )
++# pragma GCC diagnostic pop
++#endif
++#if defined( __clang__ )
++# pragma clang diagnostic pop
++#endif
++
++
++ } // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
++
++
++#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
++#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
++
++#include <type_traits>
++
++namespace Catch {
++namespace Detail {
++
++#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
++
++ using std::conjunction;
++ using std::disjunction;
++ using std::negation;
++
++#else
++
++ template <class...> struct conjunction : std::true_type {};
++ template <class B1> struct conjunction<B1> : B1 {};
++ template <class B1, class... Bn>
++ struct conjunction<B1, Bn...>
++ : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
++
++ template <class...> struct disjunction : std::false_type {};
++ template <class B1> struct disjunction<B1> : B1 {};
++ template <class B1, class... Bn>
++ struct disjunction<B1, Bn...>
++ : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
++
++ template <class B>
++ struct negation : std::integral_constant<bool, !bool(B::value)> {};
++
++#endif
++
++} // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
++
++#include <type_traits>
++#include <iosfwd>
++
++/** \file
++ * Why does decomposing look the way it does:
++ *
++ * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
++ * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
++ * and our custom operator is used for `a == b`, because `a` is transformed
++ * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
++ *
++ * In practice, decomposing ends up a mess, because we have to support
++ * various fun things.
++ *
++ * 1) Types that are only comparable with literal 0, and they do this by
++ * comparing against a magic type with pointer constructor and deleted
++ * other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
++ *
++ * 2) Types that are only comparable with literal 0, and they do this by
++ * comparing against a magic type with consteval integer constructor.
++ * Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
++ *
++ * 3) Types that have no linkage, and so we cannot form a reference to
++ * them. Example: some implementations of traits.
++ *
++ * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
++ * `b == a` when constructing the overload set. For us this means that
++ * when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
++ * the overload set for `b == ExprLhs<T>`.
++ *
++ * To accomodate these use cases, decomposer ended up rather complex.
++ *
++ * 1) These types are handled by adding SFINAE overloads to our comparison
++ * operators, checking whether `T == U` are comparable with the given
++ * operator, and if not, whether T (or U) are comparable with literal 0.
++ * If yes, the overload compares T (or U) with 0 literal inline in the
++ * definition.
++ *
++ * Note that for extra correctness, we check that the other type is
++ * either an `int` (literal 0 is captured as `int` by templates), or
++ * a `long` (some platforms use 0L for `NULL` and we want to support
++ * that for pointer comparisons).
++ *
++ * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
++ * them fall into the overload that actually does `T == int` causes
++ * compilation error. Handling them requires that the decomposition
++ * is `constexpr`, so that P2564R3 applies and the `consteval` from
++ * their accompanying magic type is propagated through the `constexpr`
++ * call stack.
++ *
++ * However this is not enough to handle these types automatically,
++ * because our default is to capture types by reference, to avoid
++ * runtime copies. While these references cannot become dangling,
++ * they outlive the constexpr context and thus the default capture
++ * path cannot be actually constexpr.
++ *
++ * The solution is to capture these types by value, by explicitly
++ * specializing `Catch::capture_by_value` for them. Catch2 provides
++ * specialization for `std::foo_ordering`s, but users can specialize
++ * the trait for their own types as well.
++ *
++ * 3) If a type has no linkage, we also cannot capture it by reference.
++ * The solution is once again to capture them by value. We handle
++ * the common cases by using `std::is_arithmetic` as the default
++ * for `Catch::capture_by_value`, but that is only a some-effort
++ * heuristic. But as with 2), users can specialize `capture_by_value`
++ * for their own types as needed.
++ *
++ * 4) To support C++20 and make the SFINAE on our decomposing operators
++ * work, the SFINAE has to happen in return type, rather than in
++ * a template type. This is due to our use of logical type traits
++ * (`conjunction`/`disjunction`/`negation`), that we use to workaround
++ * an issue in older (9-) versions of GCC. I still blame C++20 for
++ * this, because without the comparison order switching, the logical
++ * traits could still be used in template type.
++ *
++ * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
++ * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
++ * nicely into the same expression handling logic, but these are rather
++ * straightforward and add only a bit of complexity (e.g. common base
++ * class for decomposed expressions).
++ */
++
++#ifdef _MSC_VER
++#pragma warning(push)
++#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
++#pragma warning(disable:4018) // more "signed/unsigned mismatch"
++#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
++#pragma warning(disable:4180) // qualifier applied to function type has no meaning
++#pragma warning(disable:4800) // Forcing result to true or false
++#endif
++
++#ifdef __clang__
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wsign-compare"
++# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
++#elif defined __GNUC__
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wsign-compare"
++# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
++#endif
++
++#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
++# include <compare>
++# if defined( __cpp_lib_three_way_comparison ) && \
++ __cpp_lib_three_way_comparison >= 201907L
++# define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
++# endif
++#endif
++
++namespace Catch {
++
++ namespace Detail {
++ // This was added in C++20, but we require only C++14 for now.
++ template <typename T>
++ using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
++ }
++
++ // Note: There is nothing that stops us from extending this,
++ // e.g. to `std::is_scalar`, but the more encompassing
++ // traits are usually also more expensive. For now we
++ // keep this as it used to be and it can be changed later.
++ template <typename T>
++ struct capture_by_value
++ : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
++
++#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
++ template <>
++ struct capture_by_value<std::strong_ordering> : std::true_type {};
++ template <>
++ struct capture_by_value<std::weak_ordering> : std::true_type {};
++ template <>
++ struct capture_by_value<std::partial_ordering> : std::true_type {};
++#endif
++
++ template <typename T>
++ struct always_false : std::false_type {};
++
++ class ITransientExpression {
++ bool m_isBinaryExpression;
++ bool m_result;
++
++ public:
++ constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
++ constexpr auto getResult() const -> bool { return m_result; }
++ //! This function **has** to be overriden by the derived class.
++ virtual void streamReconstructedExpression( std::ostream& os ) const;
++
++ constexpr ITransientExpression( bool isBinaryExpression, bool result )
++ : m_isBinaryExpression( isBinaryExpression ),
++ m_result( result )
++ {}
++
++ ITransientExpression() = default;
++ ITransientExpression(ITransientExpression const&) = default;
++ ITransientExpression& operator=(ITransientExpression const&) = default;
++
++ friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
++ expr.streamReconstructedExpression(out);
++ return out;
++ }
++
++ protected:
++ ~ITransientExpression() = default;
++ };
++
++ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
++
++ template<typename LhsT, typename RhsT>
++ class BinaryExpr : public ITransientExpression {
++ LhsT m_lhs;
++ StringRef m_op;
++ RhsT m_rhs;
++
++ void streamReconstructedExpression( std::ostream &os ) const override {
++ formatReconstructedExpression
++ ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
++ }
++
++ public:
++ constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
++ : ITransientExpression{ true, comparisonResult },
++ m_lhs( lhs ),
++ m_op( op ),
++ m_rhs( rhs )
++ {}
++
++ template<typename T>
++ auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename T>
++ auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
++ static_assert(always_false<T>::value,
++ "chained comparisons are not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++ };
++
++ template<typename LhsT>
++ class UnaryExpr : public ITransientExpression {
++ LhsT m_lhs;
++
++ void streamReconstructedExpression( std::ostream &os ) const override {
++ os << Catch::Detail::stringify( m_lhs );
++ }
++
++ public:
++ explicit constexpr UnaryExpr( LhsT lhs )
++ : ITransientExpression{ false, static_cast<bool>(lhs) },
++ m_lhs( lhs )
++ {}
++ };
++
++
++ template<typename LhsT>
++ class ExprLhs {
++ LhsT m_lhs;
++ public:
++ explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
++
++#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
++ Detail::negation<capture_by_value< \
++ Detail::RemoveCVRef_t<RhsT>>>>::value, \
++ BinaryExpr<LhsT, RhsT const&>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
++ capture_by_value<RhsT>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction< \
++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
++ Detail::is_eq_0_comparable<LhsT>, \
++ /* We allow long because we want `ptr op NULL` to be accepted */ \
++ Detail::disjunction<std::is_same<RhsT, int>, \
++ std::is_same<RhsT, long>>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ if ( rhs != 0 ) { throw_test_failure_exception(); } \
++ return { \
++ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction< \
++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
++ Detail::is_eq_0_comparable<RhsT>, \
++ /* We allow long because we want `ptr op NULL` to be accepted */ \
++ Detail::disjunction<std::is_same<LhsT, int>, \
++ std::is_same<LhsT, long>>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
++ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ }
++
++ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
++ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
++
++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
++
++
++#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
++ Detail::negation<capture_by_value< \
++ Detail::RemoveCVRef_t<RhsT>>>>::value, \
++ BinaryExpr<LhsT, RhsT const&>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
++ capture_by_value<RhsT>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction< \
++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
++ Detail::is_##id##_0_comparable<LhsT>, \
++ std::is_same<RhsT, int>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ if ( rhs != 0 ) { throw_test_failure_exception(); } \
++ return { \
++ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t< \
++ Detail::conjunction< \
++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
++ Detail::is_##id##_0_comparable<RhsT>, \
++ std::is_same<LhsT, int>>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
++ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ }
++
++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
++
++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
++
++
++#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
++ -> std::enable_if_t< \
++ !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value, \
++ BinaryExpr<LhsT, RhsT const&>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ } \
++ template <typename RhsT> \
++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
++ -> std::enable_if_t<capture_by_value<RhsT>::value, \
++ BinaryExpr<LhsT, RhsT>> { \
++ return { \
++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
++ }
++
++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
++
++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
++
++ template<typename RhsT>
++ friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
++ static_assert(always_false<RhsT>::value,
++ "operator&& is not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ template<typename RhsT>
++ friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
++ static_assert(always_false<RhsT>::value,
++ "operator|| is not supported inside assertions, "
++ "wrap the expression inside parentheses, or decompose it");
++ }
++
++ constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
++ return UnaryExpr<LhsT>{ m_lhs };
++ }
++ };
++
++ struct Decomposer {
++ template <typename T,
++ std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
++ int> = 0>
++ constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
++ return ExprLhs<const T&>{ lhs };
++ }
++
++ template <typename T,
++ std::enable_if_t<capture_by_value<T>::value, int> = 0>
++ constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
++ return ExprLhs<T>{ value };
++ }
++ };
++
++} // end namespace Catch
++
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
++#ifdef __clang__
++# pragma clang diagnostic pop
++#elif defined __GNUC__
++# pragma GCC diagnostic pop
++#endif
++
++#endif // CATCH_DECOMPOSER_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ struct AssertionReaction {
++ bool shouldDebugBreak = false;
++ bool shouldThrow = false;
++ bool shouldSkip = false;
++ };
++
++ class AssertionHandler {
++ AssertionInfo m_assertionInfo;
++ AssertionReaction m_reaction;
++ bool m_completed = false;
++ IResultCapture& m_resultCapture;
++
++ public:
++ AssertionHandler
++ ( StringRef macroName,
++ SourceLineInfo const& lineInfo,
++ StringRef capturedExpression,
++ ResultDisposition::Flags resultDisposition );
++ ~AssertionHandler() {
++ if ( !m_completed ) {
++ m_resultCapture.handleIncomplete( m_assertionInfo );
++ }
++ }
++
++
++ template<typename T>
++ void handleExpr( ExprLhs<T> const& expr ) {
++ handleExpr( expr.makeUnaryExpr() );
++ }
++ void handleExpr( ITransientExpression const& expr );
++
++ void handleMessage(ResultWas::OfType resultType, StringRef message);
++
++ void handleExceptionThrownAsExpected();
++ void handleUnexpectedExceptionNotThrown();
++ void handleExceptionNotThrownAsExpected();
++ void handleThrowingCallSkipped();
++ void handleUnexpectedInflightException();
++
++ void complete();
++
++ // query
++ auto allowThrows() const -> bool;
++ };
++
++ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
++
++} // namespace Catch
++
++#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
++
++
++#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
++#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
++
++
++#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
++ #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
++#else
++ #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
++#endif
++
++#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
++
++// We need this suppression to leak, because it took until GCC 10
++// for the front end to handle local suppression via _Pragma properly
++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
++ #pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++#if !defined(CATCH_CONFIG_DISABLE)
++
++#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++
++///////////////////////////////////////////////////////////////////////////////
++// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
++// macros.
++#define INTERNAL_CATCH_TRY
++#define INTERNAL_CATCH_CATCH( capturer )
++
++#else // CATCH_CONFIG_FAST_COMPILE
++
++#define INTERNAL_CATCH_TRY try
++#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }
++
++#endif
++
++#define INTERNAL_CATCH_REACT( handler ) handler.complete();
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
++ do { /* NOLINT(bugprone-infinite-loop) */ \
++ /* The expression should not be evaluated, but warnings should hopefully be checked */ \
++ CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
++ INTERNAL_CATCH_TRY { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
++ catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
++ // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
++ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
++ if( Catch::getResultCapture().lastAssertionPassed() )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
++ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
++ if( !Catch::getResultCapture().lastAssertionPassed() )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
++ try { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
++ static_cast<void>(__VA_ARGS__); \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
++ } \
++ catch( ... ) { \
++ catchAssertionHandler.handleUnexpectedInflightException(); \
++ } \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
++ if( catchAssertionHandler.allowThrows() ) \
++ try { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
++ static_cast<void>(__VA_ARGS__); \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
++ } \
++ catch( ... ) { \
++ catchAssertionHandler.handleExceptionThrownAsExpected(); \
++ } \
++ else \
++ catchAssertionHandler.handleThrowingCallSkipped(); \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
++ if( catchAssertionHandler.allowThrows() ) \
++ try { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
++ static_cast<void>(expr); \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
++ } \
++ catch( exceptionType const& ) { \
++ catchAssertionHandler.handleExceptionThrownAsExpected(); \
++ } \
++ catch( ... ) { \
++ catchAssertionHandler.handleUnexpectedInflightException(); \
++ } \
++ else \
++ catchAssertionHandler.handleThrowingCallSkipped(); \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++
++
++///////////////////////////////////////////////////////////////////////////////
++// Although this is matcher-based, it can be used with just a string
++#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
++ if( catchAssertionHandler.allowThrows() ) \
++ try { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
++ static_cast<void>(__VA_ARGS__); \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
++ } \
++ catch( ... ) { \
++ Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
++ } \
++ else \
++ catchAssertionHandler.handleThrowingCallSkipped(); \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++#endif // CATCH_CONFIG_DISABLE
++
++#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
++
++
++#ifndef CATCH_SECTION_HPP_INCLUDED
++#define CATCH_SECTION_HPP_INCLUDED
++
++
++
++
++/** \file
++ * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
++ *
++ * Some of Catch2's macros can be defined differently to work better with
++ * static analysis tools, like clang-tidy or coverity.
++ * Currently the main use case is to show that `SECTION`s are executed
++ * exclusively, and not all in one run of a `TEST_CASE`.
++ */
++
++#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
++#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
++
++
++#if defined(__clang_analyzer__) || defined(__COVERITY__)
++ #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
++#endif
++
++#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
++ !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
++ !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
++# define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
++#endif
++
++
++#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
++
++
++#ifndef CATCH_TIMER_HPP_INCLUDED
++#define CATCH_TIMER_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++
++ class Timer {
++ uint64_t m_nanoseconds = 0;
++ public:
++ void start();
++ auto getElapsedNanoseconds() const -> uint64_t;
++ auto getElapsedMicroseconds() const -> uint64_t;
++ auto getElapsedMilliseconds() const -> unsigned int;
++ auto getElapsedSeconds() const -> double;
++ };
++
++} // namespace Catch
++
++#endif // CATCH_TIMER_HPP_INCLUDED
++
++namespace Catch {
++
++ class Section : Detail::NonCopyable {
++ public:
++ Section( SectionInfo&& info );
++ Section( SourceLineInfo const& _lineInfo,
++ StringRef _name,
++ const char* const = nullptr );
++ ~Section();
++
++ // This indicates whether the section should be executed or not
++ explicit operator bool() const;
++
++ private:
++ SectionInfo m_info;
++
++ Counts m_assertions;
++ bool m_sectionIncluded;
++ Timer m_timer;
++ };
++
++} // end namespace Catch
++
++#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
++# define INTERNAL_CATCH_SECTION( ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
++ catch_internal_Section ) = \
++ Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
++ catch_internal_Section ) = \
++ Catch::SectionInfo( \
++ CATCH_INTERNAL_LINEINFO, \
++ ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
++ .str() ) ) \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++#else
++
++// These section definitions imply that at most one section at one level
++// will be intered (because only one section's __LINE__ can be equal to
++// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
++
++namespace Catch {
++ namespace Detail {
++ // Intentionally without linkage, as it should only be used as a dummy
++ // symbol for static analysis.
++ // The arguments are used as a dummy for checking warnings in the passed
++ // expressions.
++ int GetNewSectionHint( StringRef, const char* const = nullptr );
++ } // namespace Detail
++} // namespace Catch
++
++
++# define INTERNAL_CATCH_SECTION( ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
++ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
++ catchInternalSectionHint, \
++ catchInternalSectionHint = \
++ Catch::Detail::GetNewSectionHint(__VA_ARGS__); \
++ catchInternalPreviousSectionHint == __LINE__ ) \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
++ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
++ catchInternalSectionHint, \
++ catchInternalSectionHint = Catch::Detail::GetNewSectionHint( \
++ ( Catch::ReusableStringStream() << __VA_ARGS__ ).str()); \
++ catchInternalPreviousSectionHint == __LINE__ ) \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++#endif
++
++
++#endif // CATCH_SECTION_HPP_INCLUDED
++
++
++#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
++#define CATCH_TEST_REGISTRY_HPP_INCLUDED
++
++
++
++#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
++#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
++
++namespace Catch {
++
++ class ITestInvoker {
++ public:
++ virtual void invoke() const = 0;
++ virtual ~ITestInvoker(); // = default
++ };
++
++} // namespace Catch
++
++#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
++
++
++#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
++#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
++
++#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
++#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
++#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
++#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
++
++#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
++ INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )
++
++#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
++
++// GCC 5 and older do not properly handle disabling unused-variable warning
++// with a _Pragma. This means that we have to leak the suppression to the
++// user code as well :-(
++#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
++#pragma GCC diagnostic ignored "-Wunused-variable"
++#endif
++
++
++
++namespace Catch {
++
++template<typename C>
++class TestInvokerAsMethod : public ITestInvoker {
++ void (C::*m_testAsMethod)();
++public:
++ TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
++
++ void invoke() const override {
++ C obj;
++ (obj.*m_testAsMethod)();
++ }
++};
++
++Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
++
++template<typename C>
++Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
++ return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
++}
++
++struct NameAndTags {
++ constexpr NameAndTags( StringRef name_ = StringRef(),
++ StringRef tags_ = StringRef() ) noexcept:
++ name( name_ ), tags( tags_ ) {}
++ StringRef name;
++ StringRef tags;
++};
++
++struct AutoReg : Detail::NonCopyable {
++ AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
++};
++
++} // end namespace Catch
++
++#if defined(CATCH_CONFIG_DISABLE)
++ #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
++ static inline void TestName()
++ #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
++ namespace{ \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
++ void test(); \
++ }; \
++ } \
++ void TestName::test()
++#endif
++
++
++#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
++
++ ///////////////////////////////////////////////////////////////////////////////
++ #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
++ static void TestName(); \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ static void TestName()
++ #define INTERNAL_CATCH_TESTCASE( ... ) \
++ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
++
++#else // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
++
++
++// Dummy registrator for the dumy test case macros
++namespace Catch {
++ namespace Detail {
++ struct DummyUse {
++ DummyUse( void ( * )( int ), Catch::NameAndTags const& );
++ };
++ } // namespace Detail
++} // namespace Catch
++
++// Note that both the presence of the argument and its exact name are
++// necessary for the section support.
++
++// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
++// tests can compile. The redefined `TEST_CASE` shadows this with param.
++static int catchInternalSectionHint = 0;
++
++# define INTERNAL_CATCH_TESTCASE2( fname, ... ) \
++ static void fname( int ); \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME( \
++ dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } ); \
++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
++ static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++# define INTERNAL_CATCH_TESTCASE( ... ) \
++ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )
++
++
++#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
++
++ ///////////////////////////////////////////////////////////////////////////////
++ #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ namespace{ \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
++ void test(); \
++ }; \
++ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
++ Catch::makeTestInvoker( &TestName::test ), \
++ CATCH_INTERNAL_LINEINFO, \
++ #ClassName##_catch_sr, \
++ Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
++ } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ void TestName::test()
++ #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
++ INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
++
++
++ ///////////////////////////////////////////////////////////////////////////////
++ #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ namespace { \
++ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
++ Catch::makeTestInvoker( &QualifiedMethod ), \
++ CATCH_INTERNAL_LINEINFO, \
++ "&" #QualifiedMethod##_catch_sr, \
++ Catch::NameAndTags{ __VA_ARGS__ } ); \
++ } /* NOLINT */ \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++
++ ///////////////////////////////////////////////////////////////////////////////
++ #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
++ do { \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ } while(false)
++
++
++#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
++
++
++// All of our user-facing macros support configuration toggle, that
++// forces them to be defined prefixed with CATCH_. We also like to
++// support another toggle that can minimize (disable) their implementation.
++// Given this, we have 4 different configuration options below
++
++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
++
++ #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
++
++ #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
++ #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++
++ #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
++ #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++ #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++ #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++
++ #define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
++ #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++
++ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
++ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
++ #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
++ #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
++ #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
++ #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
++
++
++ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
++ #define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
++ #define CATCH_STATIC_CHECK( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
++ #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
++ #else
++ #define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ )
++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
++ #define CATCH_STATIC_CHECK( ... ) CATCH_CHECK( __VA_ARGS__ )
++ #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
++ #endif
++
++
++ // "BDD-style" convenience wrappers
++ #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
++ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
++ #define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
++ #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
++ #define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
++ #define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
++ #define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
++ #define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
++
++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
++
++ #define CATCH_REQUIRE( ... ) (void)(0)
++ #define CATCH_REQUIRE_FALSE( ... ) (void)(0)
++
++ #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
++ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
++ #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
++
++ #define CATCH_CHECK( ... ) (void)(0)
++ #define CATCH_CHECK_FALSE( ... ) (void)(0)
++ #define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__)
++ #define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
++ #define CATCH_CHECK_NOFAIL( ... ) (void)(0)
++
++ #define CATCH_CHECK_THROWS( ... ) (void)(0)
++ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
++ #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
++
++ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
++ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
++ #define CATCH_METHOD_AS_TEST_CASE( method, ... )
++ #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
++ #define CATCH_SECTION( ... )
++ #define CATCH_DYNAMIC_SECTION( ... )
++ #define CATCH_FAIL( ... ) (void)(0)
++ #define CATCH_FAIL_CHECK( ... ) (void)(0)
++ #define CATCH_SUCCEED( ... ) (void)(0)
++ #define CATCH_SKIP( ... ) (void)(0)
++
++ #define CATCH_STATIC_REQUIRE( ... ) (void)(0)
++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
++ #define CATCH_STATIC_CHECK( ... ) (void)(0)
++ #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
++
++ // "BDD-style" convenience wrappers
++ #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
++ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
++ #define CATCH_GIVEN( desc )
++ #define CATCH_AND_GIVEN( desc )
++ #define CATCH_WHEN( desc )
++ #define CATCH_AND_WHEN( desc )
++ #define CATCH_THEN( desc )
++ #define CATCH_AND_THEN( desc )
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
++
++ #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
++
++ #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
++ #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
++
++ #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
++ #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++ #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++ #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
++
++ #define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
++ #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++
++ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
++ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
++ #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
++ #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
++ #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
++ #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
++ #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
++ #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
++
++
++ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
++ #define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
++ #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
++ #define STATIC_CHECK( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
++ #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
++ #else
++ #define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ )
++ #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
++ #define STATIC_CHECK( ... ) CHECK( __VA_ARGS__ )
++ #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
++ #endif
++
++ // "BDD-style" convenience wrappers
++ #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
++ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
++ #define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
++ #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
++ #define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
++ #define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
++ #define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
++ #define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
++
++ #define REQUIRE( ... ) (void)(0)
++ #define REQUIRE_FALSE( ... ) (void)(0)
++
++ #define REQUIRE_THROWS( ... ) (void)(0)
++ #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
++ #define REQUIRE_NOTHROW( ... ) (void)(0)
++
++ #define CHECK( ... ) (void)(0)
++ #define CHECK_FALSE( ... ) (void)(0)
++ #define CHECKED_IF( ... ) if (__VA_ARGS__)
++ #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
++ #define CHECK_NOFAIL( ... ) (void)(0)
++
++ #define CHECK_THROWS( ... ) (void)(0)
++ #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
++ #define CHECK_NOTHROW( ... ) (void)(0)
++
++ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
++ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
++ #define METHOD_AS_TEST_CASE( method, ... )
++ #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
++ #define SECTION( ... )
++ #define DYNAMIC_SECTION( ... )
++ #define FAIL( ... ) (void)(0)
++ #define FAIL_CHECK( ... ) (void)(0)
++ #define SUCCEED( ... ) (void)(0)
++ #define SKIP( ... ) (void)(0)
++
++ #define STATIC_REQUIRE( ... ) (void)(0)
++ #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
++ #define STATIC_CHECK( ... ) (void)(0)
++ #define STATIC_CHECK_FALSE( ... ) (void)(0)
++
++ // "BDD-style" convenience wrappers
++ #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
++ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
++
++ #define GIVEN( desc )
++ #define AND_GIVEN( desc )
++ #define WHEN( desc )
++ #define AND_WHEN( desc )
++ #define THEN( desc )
++ #define AND_THEN( desc )
++
++#endif // ^^ unprefixed, disabled
++
++// end of user facing macros
++
++#endif // CATCH_TEST_MACROS_HPP_INCLUDED
++
++
++#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
++#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
++
++
++
++#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
++#define CATCH_PREPROCESSOR_HPP_INCLUDED
++
++
++#if defined(__GNUC__)
++// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
++#pragma GCC system_header
++#endif
++
++
++#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
++#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
++#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
++#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
++#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
++#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
++
++#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
++// MSVC needs more evaluations
++#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
++#else
++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
++#endif
++
++#define CATCH_REC_END(...)
++#define CATCH_REC_OUT
++
++#define CATCH_EMPTY()
++#define CATCH_DEFER(id) id CATCH_EMPTY()
++
++#define CATCH_REC_GET_END2() 0, CATCH_REC_END
++#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
++#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
++#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
++#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
++#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
++
++#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
++#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
++#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
++
++#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
++#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
++#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
++
++// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
++// and passes userdata as the first parameter to each invocation,
++// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
++#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
++
++#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
++
++#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
++#else
++// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
++#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
++#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
++#endif
++
++#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
++#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
++#else
++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
++#endif
++
++#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
++ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
++
++#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
++#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
++#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
++#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
++#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
++#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
++#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
++#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
++#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
++#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
++#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
++
++#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
++
++#define INTERNAL_CATCH_TYPE_GEN\
++ template<typename...> struct TypeList {};\
++ template<typename...Ts>\
++ constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
++ template<template<typename...> class...> struct TemplateTypeList{};\
++ template<template<typename...> class...Cs>\
++ constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
++ template<typename...>\
++ struct append;\
++ template<typename...>\
++ struct rewrap;\
++ template<template<typename...> class, typename...>\
++ struct create;\
++ template<template<typename...> class, typename>\
++ struct convert;\
++ \
++ template<typename T> \
++ struct append<T> { using type = T; };\
++ template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
++ struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
++ template< template<typename...> class L1, typename...E1, typename...Rest>\
++ struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
++ \
++ template< template<typename...> class Container, template<typename...> class List, typename...elems>\
++ struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
++ template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
++ struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
++ \
++ template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
++ struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
++ template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
++ struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
++
++#define INTERNAL_CATCH_NTTP_1(signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
++ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
++ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
++ constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
++ \
++ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
++ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
++ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
++ template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
++ struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
++
++#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
++#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ static void TestName()
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ static void TestName()
++
++#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
++#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ static void TestName()
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ static void TestName()
++
++#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
++ template<typename Type>\
++ void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
++ {\
++ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
++ }
++
++#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
++ {\
++ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
++ }
++
++#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
++ template<typename Type>\
++ void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
++ {\
++ Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
++ }
++
++#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
++ void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
++ {\
++ Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
++ }
++
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
++ template<typename TestType> \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
++ void test();\
++ }
++
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
++ void test();\
++ }
++
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
++ template<typename TestType> \
++ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
++ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++#define INTERNAL_CATCH_NTTP_0
++#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
++#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
++#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
++#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
++#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
++#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
++#else
++#define INTERNAL_CATCH_NTTP_0(signature)
++#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
++#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
++#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
++#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
++#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
++#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
++#endif
++
++#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
++
++
++// GCC 5 and older do not properly handle disabling unused-variable warning
++// with a _Pragma. This means that we have to leak the suppression to the
++// user code as well :-(
++#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
++#pragma GCC diagnostic ignored "-Wunused-variable"
++#endif
++
++#if defined(CATCH_CONFIG_DISABLE)
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... ) \
++ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
++ namespace{ \
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
++ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
++ } \
++ } \
++ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
++ #else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
++ #endif
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
++ #else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
++ #endif
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
++ #else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
++ #endif
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
++ #else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
++ #endif
++#endif
++
++
++ ///////////////////////////////////////////////////////////////////////////////
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
++ INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
++ INTERNAL_CATCH_TYPE_GEN\
++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
++ INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
++ template<typename...Types> \
++ struct TestName{\
++ TestName(){\
++ size_t index = 0; \
++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
++ using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
++ (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
++ }\
++ };\
++ static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
++ TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
++ return 0;\
++ }();\
++ }\
++ }\
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
++#endif
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
++#endif
++
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
++ template<typename TestType> static void TestFuncName(); \
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
++ INTERNAL_CATCH_TYPE_GEN \
++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
++ template<typename... Types> \
++ struct TestName { \
++ void reg_tests() { \
++ size_t index = 0; \
++ using expander = size_t[]; \
++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
++ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
++ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
++ } \
++ }; \
++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
++ using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
++ TestInit t; \
++ t.reg_tests(); \
++ return 0; \
++ }(); \
++ } \
++ } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ template<typename TestType> \
++ static void TestFuncName()
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
++#else
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
++#endif
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
++#else
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
++#endif
++
++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
++ template<typename TestType> static void TestFunc(); \
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
++ INTERNAL_CATCH_TYPE_GEN\
++ template<typename... Types> \
++ struct TestName { \
++ void reg_tests() { \
++ size_t index = 0; \
++ using expander = size_t[]; \
++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
++ } \
++ };\
++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
++ using TestInit = typename convert<TestName, TmplList>::type; \
++ TestInit t; \
++ t.reg_tests(); \
++ return 0; \
++ }(); \
++ }}\
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ template<typename TestType> \
++ static void TestFunc()
++
++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
++ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
++
++
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
++ INTERNAL_CATCH_TYPE_GEN\
++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
++ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
++ INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
++ template<typename...Types> \
++ struct TestNameClass{\
++ TestNameClass(){\
++ size_t index = 0; \
++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
++ using expander = size_t[];\
++ (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
++ }\
++ };\
++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
++ TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
++ return 0;\
++ }();\
++ }\
++ }\
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
++#endif
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
++#endif
++
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ template<typename TestType> \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
++ void test();\
++ };\
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
++ INTERNAL_CATCH_TYPE_GEN \
++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
++ template<typename...Types>\
++ struct TestNameClass{\
++ void reg_tests(){\
++ std::size_t index = 0;\
++ using expander = std::size_t[];\
++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
++ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
++ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
++ }\
++ };\
++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
++ using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
++ TestInit t;\
++ t.reg_tests();\
++ return 0;\
++ }(); \
++ }\
++ }\
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ template<typename TestType> \
++ void TestName<TestType>::test()
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
++#endif
++
++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
++#else
++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
++#endif
++
++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
++ template<typename TestType> \
++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
++ void test();\
++ };\
++ namespace {\
++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
++ INTERNAL_CATCH_TYPE_GEN\
++ template<typename...Types>\
++ struct TestNameClass{\
++ void reg_tests(){\
++ size_t index = 0;\
++ using expander = size_t[];\
++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
++ }\
++ };\
++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
++ using TestInit = typename convert<TestNameClass, TmplList>::type;\
++ TestInit t;\
++ t.reg_tests();\
++ return 0;\
++ }(); \
++ }}\
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ template<typename TestType> \
++ void TestName<TestType>::test()
++
++#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
++ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
++
++
++#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
++
++
++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #else
++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #endif
++
++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
++ #else
++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
++ #endif
++
++ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
++ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #else
++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
++ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
++ #endif
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
++
++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
++ #else
++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
++ #endif
++
++ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++ #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
++
++#endif // end of user facing macro declarations
++
++
++#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
++
++
++#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
++#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
++
++
++
++#include <cstdint>
++#include <string>
++#include <vector>
++
++#ifdef __clang__
++#pragma clang diagnostic push
++#pragma clang diagnostic ignored "-Wpadded"
++#endif
++
++namespace Catch {
++
++ /**
++ * A **view** of a tag string that provides case insensitive comparisons
++ *
++ * Note that in Catch2 internals, the square brackets around tags are
++ * not a part of tag's representation, so e.g. "[cool-tag]" is represented
++ * as "cool-tag" internally.
++ */
++ struct Tag {
++ constexpr Tag(StringRef original_):
++ original(original_)
++ {}
++ StringRef original;
++
++ friend bool operator< ( Tag const& lhs, Tag const& rhs );
++ friend bool operator==( Tag const& lhs, Tag const& rhs );
++ };
++
++ class ITestInvoker;
++ struct NameAndTags;
++
++ enum class TestCaseProperties : uint8_t {
++ None = 0,
++ IsHidden = 1 << 1,
++ ShouldFail = 1 << 2,
++ MayFail = 1 << 3,
++ Throws = 1 << 4,
++ NonPortable = 1 << 5,
++ Benchmark = 1 << 6
++ };
++
++ /**
++ * Various metadata about the test case.
++ *
++ * A test case is uniquely identified by its (class)name and tags
++ * combination, with source location being ignored, and other properties
++ * being determined from tags.
++ *
++ * Tags are kept sorted.
++ */
++ struct TestCaseInfo : Detail::NonCopyable {
++
++ TestCaseInfo(StringRef _className,
++ NameAndTags const& _nameAndTags,
++ SourceLineInfo const& _lineInfo);
++
++ bool isHidden() const;
++ bool throws() const;
++ bool okToFail() const;
++ bool expectedToFail() const;
++
++ // Adds the tag(s) with test's filename (for the -# flag)
++ void addFilenameTag();
++
++ //! Orders by name, classname and tags
++ friend bool operator<( TestCaseInfo const& lhs,
++ TestCaseInfo const& rhs );
++
++
++ std::string tagsAsString() const;
++
++ std::string name;
++ StringRef className;
++ private:
++ std::string backingTags;
++ // Internally we copy tags to the backing storage and then add
++ // refs to this storage to the tags vector.
++ void internalAppendTag(StringRef tagString);
++ public:
++ std::vector<Tag> tags;
++ SourceLineInfo lineInfo;
++ TestCaseProperties properties = TestCaseProperties::None;
++ };
++
++ /**
++ * Wrapper over the test case information and the test case invoker
++ *
++ * Does not own either, and is specifically made to be cheap
++ * to copy around.
++ */
++ class TestCaseHandle {
++ TestCaseInfo* m_info;
++ ITestInvoker* m_invoker;
++ public:
++ TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
++ m_info(info), m_invoker(invoker) {}
++
++ void invoke() const {
++ m_invoker->invoke();
++ }
++
++ TestCaseInfo const& getTestCaseInfo() const;
++ };
++
++ Detail::unique_ptr<TestCaseInfo>
++ makeTestCaseInfo( StringRef className,
++ NameAndTags const& nameAndTags,
++ SourceLineInfo const& lineInfo );
++}
++
++#ifdef __clang__
++#pragma clang diagnostic pop
++#endif
++
++#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
++
++
++#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
++#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
++
++
++
++#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
++#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
++
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++ using exceptionTranslateFunction = std::string(*)();
++
++ class IExceptionTranslator;
++ using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
++
++ class IExceptionTranslator {
++ public:
++ virtual ~IExceptionTranslator(); // = default
++ virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
++ };
++
++ class IExceptionTranslatorRegistry {
++ public:
++ virtual ~IExceptionTranslatorRegistry(); // = default
++ virtual std::string translateActiveException() const = 0;
++ };
++
++} // namespace Catch
++
++#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
++
++#include <exception>
++
++namespace Catch {
++ namespace Detail {
++ void registerTranslatorImpl(
++ Detail::unique_ptr<IExceptionTranslator>&& translator );
++ }
++
++ class ExceptionTranslatorRegistrar {
++ template<typename T>
++ class ExceptionTranslator : public IExceptionTranslator {
++ public:
++
++ ExceptionTranslator( std::string(*translateFunction)( T const& ) )
++ : m_translateFunction( translateFunction )
++ {}
++
++ std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ try {
++ if( it == itEnd )
++ std::rethrow_exception(std::current_exception());
++ else
++ return (*it)->translate( it+1, itEnd );
++ }
++ catch( T const& ex ) {
++ return m_translateFunction( ex );
++ }
++#else
++ return "You should never get here!";
++#endif
++ }
++
++ protected:
++ std::string(*m_translateFunction)( T const& );
++ };
++
++ public:
++ template<typename T>
++ ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
++ Detail::registerTranslatorImpl(
++ Detail::make_unique<ExceptionTranslator<T>>(
++ translateFunction ) );
++ }
++ };
++
++} // namespace Catch
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
++ static std::string translatorName( signature ); \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
++ static std::string translatorName( signature )
++
++#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
++
++#if defined(CATCH_CONFIG_DISABLE)
++ #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
++ static std::string translatorName( signature )
++#endif
++
++
++// This macro is always prefixed
++#if !defined(CATCH_CONFIG_DISABLE)
++#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
++#else
++#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
++#endif
++
++
++#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
++
++
++#ifndef CATCH_VERSION_HPP_INCLUDED
++#define CATCH_VERSION_HPP_INCLUDED
++
++#include <iosfwd>
++
++namespace Catch {
++
++ // Versioning information
++ struct Version {
++ Version( Version const& ) = delete;
++ Version& operator=( Version const& ) = delete;
++ Version( unsigned int _majorVersion,
++ unsigned int _minorVersion,
++ unsigned int _patchNumber,
++ char const * const _branchName,
++ unsigned int _buildNumber );
++
++ unsigned int const majorVersion;
++ unsigned int const minorVersion;
++ unsigned int const patchNumber;
++
++ // buildNumber is only used if branchName is not null
++ char const * const branchName;
++ unsigned int const buildNumber;
++
++ friend std::ostream& operator << ( std::ostream& os, Version const& version );
++ };
++
++ Version const& libraryVersion();
++}
++
++#endif // CATCH_VERSION_HPP_INCLUDED
++
++
++#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
++#define CATCH_VERSION_MACROS_HPP_INCLUDED
++
++#define CATCH_VERSION_MAJOR 3
++#define CATCH_VERSION_MINOR 6
++#define CATCH_VERSION_PATCH 0
++
++#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
++
++
++/** \file
++ * This is a convenience header for Catch2's Generator support. It includes
++ * **all** of Catch2 headers related to generators.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of (significantly) increased
++ * compilation times.
++ *
++ * When a new header is added to either the `generators` folder,
++ * or to the corresponding internal subfolder, it should be added here.
++ */
++
++#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
++#define CATCH_GENERATORS_ALL_HPP_INCLUDED
++
++
++
++#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
++#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
++
++#include <exception>
++
++namespace Catch {
++
++ // Exception type to be thrown when a Generator runs into an error,
++ // e.g. it cannot initialize the first return value based on
++ // runtime information
++ class GeneratorException : public std::exception {
++ const char* const m_msg = "";
++
++ public:
++ GeneratorException(const char* msg):
++ m_msg(msg)
++ {}
++
++ const char* what() const noexcept override final;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
++
++
++#ifndef CATCH_GENERATORS_HPP_INCLUDED
++#define CATCH_GENERATORS_HPP_INCLUDED
++
++
++
++#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
++#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ namespace Generators {
++ class GeneratorUntypedBase {
++ // Caches result from `toStringImpl`, assume that when it is an
++ // empty string, the cache is invalidated.
++ mutable std::string m_stringReprCache;
++
++ // Counts based on `next` returning true
++ std::size_t m_currentElementIndex = 0;
++
++ /**
++ * Attempts to move the generator to the next element
++ *
++ * Returns true iff the move succeeded (and a valid element
++ * can be retrieved).
++ */
++ virtual bool next() = 0;
++
++ //! Customization point for `currentElementAsString`
++ virtual std::string stringifyImpl() const = 0;
++
++ public:
++ GeneratorUntypedBase() = default;
++ // Generation of copy ops is deprecated (and Clang will complain)
++ // if there is a user destructor defined
++ GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
++ GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
++
++ virtual ~GeneratorUntypedBase(); // = default;
++
++ /**
++ * Attempts to move the generator to the next element
++ *
++ * Serves as a non-virtual interface to `next`, so that the
++ * top level interface can provide sanity checking and shared
++ * features.
++ *
++ * As with `next`, returns true iff the move succeeded and
++ * the generator has new valid element to provide.
++ */
++ bool countedNext();
++
++ std::size_t currentElementIndex() const { return m_currentElementIndex; }
++
++ /**
++ * Returns generator's current element as user-friendly string.
++ *
++ * By default returns string equivalent to calling
++ * `Catch::Detail::stringify` on the current element, but generators
++ * can customize their implementation as needed.
++ *
++ * Not thread-safe due to internal caching.
++ *
++ * The returned ref is valid only until the generator instance
++ * is destructed, or it moves onto the next element, whichever
++ * comes first.
++ */
++ StringRef currentElementAsString() const;
++ };
++ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
++
++ } // namespace Generators
++
++ class IGeneratorTracker {
++ public:
++ virtual ~IGeneratorTracker(); // = default;
++ virtual auto hasGenerator() const -> bool = 0;
++ virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
++ virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
++ };
++
++} // namespace Catch
++
++#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
++
++#include <vector>
++#include <tuple>
++
++namespace Catch {
++
++namespace Generators {
++
++namespace Detail {
++
++ //! Throws GeneratorException with the provided message
++ [[noreturn]]
++ void throw_generator_exception(char const * msg);
++
++} // end namespace detail
++
++ template<typename T>
++ class IGenerator : public GeneratorUntypedBase {
++ std::string stringifyImpl() const override {
++ return ::Catch::Detail::stringify( get() );
++ }
++
++ public:
++ // Returns the current element of the generator
++ //
++ // \Precondition The generator is either freshly constructed,
++ // or the last call to `next()` returned true
++ virtual T const& get() const = 0;
++ using type = T;
++ };
++
++ template <typename T>
++ using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
++
++ template <typename T>
++ class GeneratorWrapper final {
++ GeneratorPtr<T> m_generator;
++ public:
++ //! Takes ownership of the passed pointer.
++ GeneratorWrapper(IGenerator<T>* generator):
++ m_generator(generator) {}
++ GeneratorWrapper(GeneratorPtr<T> generator):
++ m_generator(CATCH_MOVE(generator)) {}
++
++ T const& get() const {
++ return m_generator->get();
++ }
++ bool next() {
++ return m_generator->countedNext();
++ }
++ };
++
++
++ template<typename T>
++ class SingleValueGenerator final : public IGenerator<T> {
++ T m_value;
++ public:
++ SingleValueGenerator(T const& value) :
++ m_value(value)
++ {}
++ SingleValueGenerator(T&& value):
++ m_value(CATCH_MOVE(value))
++ {}
++
++ T const& get() const override {
++ return m_value;
++ }
++ bool next() override {
++ return false;
++ }
++ };
++
++ template<typename T>
++ class FixedValuesGenerator final : public IGenerator<T> {
++ static_assert(!std::is_same<T, bool>::value,
++ "FixedValuesGenerator does not support bools because of std::vector<bool>"
++ "specialization, use SingleValue Generator instead.");
++ std::vector<T> m_values;
++ size_t m_idx = 0;
++ public:
++ FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
++
++ T const& get() const override {
++ return m_values[m_idx];
++ }
++ bool next() override {
++ ++m_idx;
++ return m_idx < m_values.size();
++ }
++ };
++
++ template <typename T, typename DecayedT = std::decay_t<T>>
++ GeneratorWrapper<DecayedT> value( T&& value ) {
++ return GeneratorWrapper<DecayedT>(
++ Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
++ CATCH_FORWARD( value ) ) );
++ }
++ template <typename T>
++ GeneratorWrapper<T> values(std::initializer_list<T> values) {
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
++ }
++
++ template<typename T>
++ class Generators : public IGenerator<T> {
++ std::vector<GeneratorWrapper<T>> m_generators;
++ size_t m_current = 0;
++
++ void add_generator( GeneratorWrapper<T>&& generator ) {
++ m_generators.emplace_back( CATCH_MOVE( generator ) );
++ }
++ void add_generator( T const& val ) {
++ m_generators.emplace_back( value( val ) );
++ }
++ void add_generator( T&& val ) {
++ m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
++ }
++ template <typename U>
++ std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
++ add_generator( U&& val ) {
++ add_generator( T( CATCH_FORWARD( val ) ) );
++ }
++
++ template <typename U> void add_generators( U&& valueOrGenerator ) {
++ add_generator( CATCH_FORWARD( valueOrGenerator ) );
++ }
++
++ template <typename U, typename... Gs>
++ void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
++ add_generator( CATCH_FORWARD( valueOrGenerator ) );
++ add_generators( CATCH_FORWARD( moreGenerators )... );
++ }
++
++ public:
++ template <typename... Gs>
++ Generators(Gs &&... moreGenerators) {
++ m_generators.reserve(sizeof...(Gs));
++ add_generators(CATCH_FORWARD(moreGenerators)...);
++ }
++
++ T const& get() const override {
++ return m_generators[m_current].get();
++ }
++
++ bool next() override {
++ if (m_current >= m_generators.size()) {
++ return false;
++ }
++ const bool current_status = m_generators[m_current].next();
++ if (!current_status) {
++ ++m_current;
++ }
++ return m_current < m_generators.size();
++ }
++ };
++
++
++ template <typename... Ts>
++ GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
++ table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
++ return values<std::tuple<Ts...>>( tuples );
++ }
++
++ // Tag type to signal that a generator sequence should convert arguments to a specific type
++ template <typename T>
++ struct as {};
++
++ template<typename T, typename... Gs>
++ auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
++ return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
++ }
++ template<typename T>
++ auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
++ return Generators<T>(CATCH_MOVE(generator));
++ }
++ template<typename T, typename... Gs>
++ auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
++ return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
++ }
++ template<typename T, typename U, typename... Gs>
++ auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
++ return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
++ }
++
++ IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
++ SourceLineInfo const& lineInfo );
++ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
++ SourceLineInfo lineInfo,
++ GeneratorBasePtr&& generator );
++
++ template<typename L>
++ auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
++ using UnderlyingType = typename decltype(generatorExpression())::type;
++
++ IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
++ // Creation of tracker is delayed after generator creation, so
++ // that constructing generator can fail without breaking everything.
++ if (!tracker) {
++ tracker = createGeneratorTracker(
++ generatorName,
++ lineInfo,
++ Catch::Detail::make_unique<Generators<UnderlyingType>>(
++ generatorExpression() ) );
++ }
++
++ auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
++ return generator.get();
++ }
++
++} // namespace Generators
++} // namespace Catch
++
++#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
++#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
++
++#define GENERATE( ... ) \
++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
++ CATCH_INTERNAL_LINEINFO, \
++ [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
++#define GENERATE_COPY( ... ) \
++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
++ CATCH_INTERNAL_LINEINFO, \
++ [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
++#define GENERATE_REF( ... ) \
++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
++ CATCH_INTERNAL_LINEINFO, \
++ [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
++
++#endif // CATCH_GENERATORS_HPP_INCLUDED
++
++
++#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
++#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
++
++
++#include <cassert>
++
++namespace Catch {
++namespace Generators {
++
++ template <typename T>
++ class TakeGenerator final : public IGenerator<T> {
++ GeneratorWrapper<T> m_generator;
++ size_t m_returned = 0;
++ size_t m_target;
++ public:
++ TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
++ m_generator(CATCH_MOVE(generator)),
++ m_target(target)
++ {
++ assert(target != 0 && "Empty generators are not allowed");
++ }
++ T const& get() const override {
++ return m_generator.get();
++ }
++ bool next() override {
++ ++m_returned;
++ if (m_returned >= m_target) {
++ return false;
++ }
++
++ const auto success = m_generator.next();
++ // If the underlying generator does not contain enough values
++ // then we cut short as well
++ if (!success) {
++ m_returned = m_target;
++ }
++ return success;
++ }
++ };
++
++ template <typename T>
++ GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
++ }
++
++
++ template <typename T, typename Predicate>
++ class FilterGenerator final : public IGenerator<T> {
++ GeneratorWrapper<T> m_generator;
++ Predicate m_predicate;
++ public:
++ template <typename P = Predicate>
++ FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
++ m_generator(CATCH_MOVE(generator)),
++ m_predicate(CATCH_FORWARD(pred))
++ {
++ if (!m_predicate(m_generator.get())) {
++ // It might happen that there are no values that pass the
++ // filter. In that case we throw an exception.
++ auto has_initial_value = next();
++ if (!has_initial_value) {
++ Detail::throw_generator_exception("No valid value found in filtered generator");
++ }
++ }
++ }
++
++ T const& get() const override {
++ return m_generator.get();
++ }
++
++ bool next() override {
++ bool success = m_generator.next();
++ if (!success) {
++ return false;
++ }
++ while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
++ return success;
++ }
++ };
++
++
++ template <typename T, typename Predicate>
++ GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
++ }
++
++ template <typename T>
++ class RepeatGenerator final : public IGenerator<T> {
++ static_assert(!std::is_same<T, bool>::value,
++ "RepeatGenerator currently does not support bools"
++ "because of std::vector<bool> specialization");
++ GeneratorWrapper<T> m_generator;
++ mutable std::vector<T> m_returned;
++ size_t m_target_repeats;
++ size_t m_current_repeat = 0;
++ size_t m_repeat_index = 0;
++ public:
++ RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
++ m_generator(CATCH_MOVE(generator)),
++ m_target_repeats(repeats)
++ {
++ assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
++ }
++
++ T const& get() const override {
++ if (m_current_repeat == 0) {
++ m_returned.push_back(m_generator.get());
++ return m_returned.back();
++ }
++ return m_returned[m_repeat_index];
++ }
++
++ bool next() override {
++ // There are 2 basic cases:
++ // 1) We are still reading the generator
++ // 2) We are reading our own cache
++
++ // In the first case, we need to poke the underlying generator.
++ // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
++ if (m_current_repeat == 0) {
++ const auto success = m_generator.next();
++ if (!success) {
++ ++m_current_repeat;
++ }
++ return m_current_repeat < m_target_repeats;
++ }
++
++ // In the second case, we need to move indices forward and check that we haven't run up against the end
++ ++m_repeat_index;
++ if (m_repeat_index == m_returned.size()) {
++ m_repeat_index = 0;
++ ++m_current_repeat;
++ }
++ return m_current_repeat < m_target_repeats;
++ }
++ };
++
++ template <typename T>
++ GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
++ }
++
++ template <typename T, typename U, typename Func>
++ class MapGenerator final : public IGenerator<T> {
++ // TBD: provide static assert for mapping function, for friendly error message
++ GeneratorWrapper<U> m_generator;
++ Func m_function;
++ // To avoid returning dangling reference, we have to save the values
++ T m_cache;
++ public:
++ template <typename F2 = Func>
++ MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
++ m_generator(CATCH_MOVE(generator)),
++ m_function(CATCH_FORWARD(function)),
++ m_cache(m_function(m_generator.get()))
++ {}
++
++ T const& get() const override {
++ return m_cache;
++ }
++ bool next() override {
++ const auto success = m_generator.next();
++ if (success) {
++ m_cache = m_function(m_generator.get());
++ }
++ return success;
++ }
++ };
++
++ template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
++ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
++ return GeneratorWrapper<T>(
++ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
++ );
++ }
++
++ template <typename T, typename U, typename Func>
++ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
++ return GeneratorWrapper<T>(
++ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
++ );
++ }
++
++ template <typename T>
++ class ChunkGenerator final : public IGenerator<std::vector<T>> {
++ std::vector<T> m_chunk;
++ size_t m_chunk_size;
++ GeneratorWrapper<T> m_generator;
++ bool m_used_up = false;
++ public:
++ ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
++ m_chunk_size(size), m_generator(CATCH_MOVE(generator))
++ {
++ m_chunk.reserve(m_chunk_size);
++ if (m_chunk_size != 0) {
++ m_chunk.push_back(m_generator.get());
++ for (size_t i = 1; i < m_chunk_size; ++i) {
++ if (!m_generator.next()) {
++ Detail::throw_generator_exception("Not enough values to initialize the first chunk");
++ }
++ m_chunk.push_back(m_generator.get());
++ }
++ }
++ }
++ std::vector<T> const& get() const override {
++ return m_chunk;
++ }
++ bool next() override {
++ m_chunk.clear();
++ for (size_t idx = 0; idx < m_chunk_size; ++idx) {
++ if (!m_generator.next()) {
++ return false;
++ }
++ m_chunk.push_back(m_generator.get());
++ }
++ return true;
++ }
++ };
++
++ template <typename T>
++ GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
++ return GeneratorWrapper<std::vector<T>>(
++ Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
++ );
++ }
++
++} // namespace Generators
++} // namespace Catch
++
++
++#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
++
++
++#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
++#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
++
++
++
++#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
++#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++
++ // This is a simple implementation of C++11 Uniform Random Number
++ // Generator. It does not provide all operators, because Catch2
++ // does not use it, but it should behave as expected inside stdlib's
++ // distributions.
++ // The implementation is based on the PCG family (http://pcg-random.org)
++ class SimplePcg32 {
++ using state_type = std::uint64_t;
++ public:
++ using result_type = std::uint32_t;
++ static constexpr result_type (min)() {
++ return 0;
++ }
++ static constexpr result_type (max)() {
++ return static_cast<result_type>(-1);
++ }
++
++ // Provide some default initial state for the default constructor
++ SimplePcg32():SimplePcg32(0xed743cc4U) {}
++
++ explicit SimplePcg32(result_type seed_);
++
++ void seed(result_type seed_);
++ void discard(uint64_t skip);
++
++ result_type operator()();
++
++ private:
++ friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
++ friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
++
++ // In theory we also need operator<< and operator>>
++ // In practice we do not use them, so we will skip them for now
++
++
++ std::uint64_t m_state;
++ // This part of the state determines which "stream" of the numbers
++ // is chosen -- we take it as a constant for Catch2, so we only
++ // need to deal with seeding the main state.
++ // Picked by reading 8 bytes from `/dev/random` :-)
++ static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
++
++
++
++#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
++#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
++
++
++
++
++#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
++#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
++
++#include <climits>
++#include <cstddef>
++#include <cstdint>
++#include <type_traits>
++
++// Note: We use the usual enable-disable-autodetect dance here even though
++// we do not support these in CMake configuration options (yet?).
++// It is highly unlikely that we will need to make these actually
++// user-configurable, but this will make it simpler if weend up needing
++// it, and it provides an escape hatch to the users who need it.
++#if defined( __SIZEOF_INT128__ )
++# define CATCH_CONFIG_INTERNAL_UINT128
++// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
++// Currently we do not bother doing this ourselves, but we could if it became
++// important for perf.
++#elif defined( _MSC_VER ) && defined( _M_X64 )
++# define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
++#endif
++
++#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
++ !defined( CATCH_CONFIG_NO_UINT128 ) && \
++ !defined( CATCH_CONFIG_UINT128 )
++#define CATCH_CONFIG_UINT128
++#endif
++
++#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
++ !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) && \
++ !defined( CATCH_CONFIG_MSVC_UMUL128 )
++# define CATCH_CONFIG_MSVC_UMUL128
++# include <intrin.h>
++#endif
++
++
++namespace Catch {
++ namespace Detail {
++
++ template <std::size_t>
++ struct SizedUnsignedType;
++#define SizedUnsignedTypeHelper( TYPE ) \
++ template <> \
++ struct SizedUnsignedType<sizeof( TYPE )> { \
++ using type = TYPE; \
++ }
++
++ SizedUnsignedTypeHelper( std::uint8_t );
++ SizedUnsignedTypeHelper( std::uint16_t );
++ SizedUnsignedTypeHelper( std::uint32_t );
++ SizedUnsignedTypeHelper( std::uint64_t );
++#undef SizedUnsignedTypeHelper
++
++ template <std::size_t sz>
++ using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;
++
++ template <typename T>
++ using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;
++
++ template <typename T>
++ struct ExtendedMultResult {
++ T upper;
++ T lower;
++ bool operator==( ExtendedMultResult const& rhs ) const {
++ return upper == rhs.upper && lower == rhs.lower;
++ }
++ };
++
++ /**
++ * Returns 128 bit result of lhs * rhs using portable C++ code
++ *
++ * This implementation is almost twice as fast as naive long multiplication,
++ * and unlike intrinsic-based approach, it supports constexpr evaluation.
++ */
++ constexpr ExtendedMultResult<std::uint64_t>
++ extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
++#define CarryBits( x ) ( x >> 32 )
++#define Digits( x ) ( x & 0xFF'FF'FF'FF )
++ std::uint64_t lhs_low = Digits( lhs );
++ std::uint64_t rhs_low = Digits( rhs );
++ std::uint64_t low_low = ( lhs_low * rhs_low );
++ std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );
++
++ // We add in carry bits from low-low already
++ std::uint64_t high_low =
++ ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
++ // Note that we can add only low bits from high_low, to avoid
++ // overflow with large inputs
++ std::uint64_t low_high =
++ ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
++
++ return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
++ ( low_high << 32 ) | Digits( low_low ) };
++#undef CarryBits
++#undef Digits
++ }
++
++ //! Returns 128 bit result of lhs * rhs
++ inline ExtendedMultResult<std::uint64_t>
++ extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
++#if defined( CATCH_CONFIG_UINT128 )
++ auto result = __uint128_t( lhs ) * __uint128_t( rhs );
++ return { static_cast<std::uint64_t>( result >> 64 ),
++ static_cast<std::uint64_t>( result ) };
++#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
++ std::uint64_t high;
++ std::uint64_t low = _umul128( lhs, rhs, &high );
++ return { high, low };
++#else
++ return extendedMultPortable( lhs, rhs );
++#endif
++ }
++
++
++ template <typename UInt>
++ constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
++ static_assert( std::is_unsigned<UInt>::value,
++ "extendedMult can only handle unsigned integers" );
++ static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
++ "Generic extendedMult can only handle types smaller "
++ "than uint64_t" );
++ using WideType = DoubleWidthUnsignedType_t<UInt>;
++
++ auto result = WideType( lhs ) * WideType( rhs );
++ return {
++ static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
++ static_cast<UInt>( result & UInt( -1 ) ) };
++ }
++
++
++ template <typename TargetType,
++ typename Generator>
++ std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
++ TargetType> fillBitsFrom(Generator& gen) {
++ using gresult_type = typename Generator::result_type;
++ static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
++ static_assert( Generator::min() == 0 &&
++ Generator::max() == static_cast<gresult_type>( -1 ),
++ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
++
++ // We want to return the top bits from a generator, as they are
++ // usually considered higher quality.
++ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
++ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
++
++ return static_cast<TargetType>( gen() >>
++ ( generated_bits - return_bits) );
++ }
++
++ template <typename TargetType,
++ typename Generator>
++ std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
++ TargetType> fillBitsFrom(Generator& gen) {
++ using gresult_type = typename Generator::result_type;
++ static_assert( std::is_unsigned<TargetType>::value,
++ "Only unsigned integers are supported" );
++ static_assert( Generator::min() == 0 &&
++ Generator::max() == static_cast<gresult_type>( -1 ),
++ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
++
++ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
++ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
++ std::size_t filled_bits = 0;
++ TargetType ret = 0;
++ do {
++ ret <<= generated_bits;
++ ret |= gen();
++ filled_bits += generated_bits;
++ } while ( filled_bits < return_bits );
++
++ return ret;
++ }
++
++ /*
++ * Transposes numbers into unsigned type while keeping their ordering
++ *
++ * This means that signed types are changed so that the ordering is
++ * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
++ * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
++ */
++ template <typename OriginalType, typename UnsignedType>
++ std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
++ transposeToNaturalOrder( UnsignedType in ) {
++ static_assert(
++ sizeof( OriginalType ) == sizeof( UnsignedType ),
++ "reordering requires the same sized types on both sides" );
++ static_assert( std::is_unsigned<UnsignedType>::value,
++ "Input type must be unsigned" );
++ // Assuming 2s complement (standardized in current C++), the
++ // positive and negative numbers are already internally ordered,
++ // and their difference is in the top bit. Swapping it orders
++ // them the desired way.
++ constexpr auto highest_bit =
++ UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
++ return static_cast<UnsignedType>( in ^ highest_bit );
++ }
++
++
++
++ template <typename OriginalType,
++ typename UnsignedType>
++ std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
++ transposeToNaturalOrder(UnsignedType in) {
++ static_assert(
++ sizeof( OriginalType ) == sizeof( UnsignedType ),
++ "reordering requires the same sized types on both sides" );
++ static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
++ // No reordering is needed for unsigned -> unsigned
++ return in;
++ }
++ } // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
++
++namespace Catch {
++
++/**
++ * Implementation of uniform distribution on integers.
++ *
++ * Unlike `std::uniform_int_distribution`, this implementation supports
++ * various 1 byte integral types, including bool (but you should not
++ * actually use it for bools).
++ *
++ * The underlying algorithm is based on the one described in "Fast Random
++ * Integer Generation in an Interval" by Daniel Lemire, but has been
++ * optimized under the assumption of reuse of the same distribution object.
++ */
++template <typename IntegerType>
++class uniform_integer_distribution {
++ static_assert(std::is_integral<IntegerType>::value, "...");
++
++ using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
++
++ // Only the left bound is stored, and we store it converted to its
++ // unsigned image. This avoids having to do the conversions inside
++ // the operator(), at the cost of having to do the conversion in
++ // the a() getter. The right bound is only needed in the b() getter,
++ // so we recompute it there from other stored data.
++ UnsignedIntegerType m_a;
++
++ // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
++ UnsignedIntegerType m_ab_distance;
++
++ // We hoisted this out of the main generation function. Technically,
++ // this means that using this distribution will be slower than Lemire's
++ // algorithm if this distribution instance will be used only few times,
++ // but it will be faster if it is used many times. Since Catch2 uses
++ // distributions only to implement random generators, we assume that each
++ // distribution will be reused many times and this is an optimization.
++ UnsignedIntegerType m_rejection_threshold = 0;
++
++ UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
++ // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
++ // We handle that later when generating the number.
++ return transposeTo(b) - transposeTo(a) + 1;
++ }
++
++ static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
++ // distance == 0 means that we will return all possible values from
++ // the type's range, and that we shouldn't reject anything.
++ if ( ab_distance == 0 ) { return 0; }
++ return ( ~ab_distance + 1 ) % ab_distance;
++ }
++
++ static UnsignedIntegerType transposeTo(IntegerType in) {
++ return Detail::transposeToNaturalOrder<IntegerType>(
++ static_cast<UnsignedIntegerType>( in ) );
++ }
++ static IntegerType transposeBack(UnsignedIntegerType in) {
++ return static_cast<IntegerType>(
++ Detail::transposeToNaturalOrder<IntegerType>(in) );
++ }
++
++public:
++ using result_type = IntegerType;
++
++ uniform_integer_distribution( IntegerType a, IntegerType b ):
++ m_a( transposeTo(a) ),
++ m_ab_distance( computeDistance(a, b) ),
++ m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
++ assert( a <= b );
++ }
++
++ template <typename Generator>
++ result_type operator()( Generator& g ) {
++ // All possible values of result_type are valid.
++ if ( m_ab_distance == 0 ) {
++ return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
++ }
++
++ auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
++ auto emul = Detail::extendedMult( random_number, m_ab_distance );
++ // Unlike Lemire's algorithm we skip the ab_distance check, since
++ // we precomputed the rejection threshold, which is always tighter.
++ while (emul.lower < m_rejection_threshold) {
++ random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
++ emul = Detail::extendedMult( random_number, m_ab_distance );
++ }
++
++ return transposeBack(m_a + emul.upper);
++ }
++
++ result_type a() const { return transposeBack(m_a); }
++ result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
++};
++
++} // end namespace Catch
++
++#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
++
++
++
++#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
++#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
++
++
++
++
++#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
++#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
++
++
++
++#ifndef CATCH_POLYFILLS_HPP_INCLUDED
++#define CATCH_POLYFILLS_HPP_INCLUDED
++
++namespace Catch {
++
++ bool isnan(float f);
++ bool isnan(double d);
++
++ float nextafter(float x, float y);
++ double nextafter(double x, double y);
++
++}
++
++#endif // CATCH_POLYFILLS_HPP_INCLUDED
++
++#include <cassert>
++#include <cmath>
++#include <cstdint>
++#include <limits>
++#include <type_traits>
++
++namespace Catch {
++
++ namespace Detail {
++ /**
++ * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
++ *
++ * Assumes `a < b`.
++ */
++ template <typename FloatType>
++ FloatType gamma(FloatType a, FloatType b) {
++ static_assert( std::is_floating_point<FloatType>::value,
++ "gamma returns the largest ULP magnitude within "
++ "floating point range [a, b]. This only makes sense "
++ "for floating point types" );
++ assert( a <= b );
++
++ const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
++ const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );
++
++ return gamma_up < gamma_down ? gamma_down : gamma_up;
++ }
++
++ template <typename FloatingPoint>
++ struct DistanceTypePicker;
++ template <>
++ struct DistanceTypePicker<float> {
++ using type = std::uint32_t;
++ };
++ template <>
++ struct DistanceTypePicker<double> {
++ using type = std::uint64_t;
++ };
++
++ template <typename T>
++ using DistanceType = typename DistanceTypePicker<T>::type;
++
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wfloat-equal"
++#endif
++ /**
++ * Computes the number of equi-distant floats in [a, b]
++ *
++ * Since not every range can be split into equidistant floats
++ * exactly, we actually compute ceil(b/distance - a/distance),
++ * because in those cases we want to overcount.
++ *
++ * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
++ */
++ template <typename FloatType>
++ DistanceType<FloatType>
++ count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
++ assert( a <= b );
++ // We get distance as gamma for our uniform float distribution,
++ // so this will round perfectly.
++ const auto ag = a / distance;
++ const auto bg = b / distance;
++
++ const auto s = bg - ag;
++ const auto err = ( std::fabs( a ) <= std::fabs( b ) )
++ ? -ag - ( s - bg )
++ : bg - ( s + ag );
++ const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );
++
++ return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
++ }
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic pop
++#endif
++
++ }
++
++} // end namespace Catch
++
++#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
++
++#include <cmath>
++#include <type_traits>
++
++namespace Catch {
++
++ namespace Detail {
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wfloat-equal"
++#endif
++ // The issue with overflow only happens with maximal ULP and HUGE
++ // distance, e.g. when generating numbers in [-inf, inf] for given
++ // type. So we only check for the largest possible ULP in the
++ // type, and return something that does not overflow to inf in 1 mult.
++ constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
++ if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
++ return static_cast<std::uint64_t>( -1 );
++ }
++ constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
++ if ( gamma == 2.028241e+31f ) { return 16777215; }
++ return static_cast<std::uint32_t>( -1 );
++ }
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic pop
++#endif
++ }
++
++/**
++ * Implementation of uniform distribution on floating point numbers.
++ *
++ * Note that we support only `float` and `double` types, because these
++ * usually mean the same thing across different platform. `long double`
++ * varies wildly by platform and thus we cannot provide reproducible
++ * implementation. Also note that we don't implement all parts of
++ * distribution per standard: this distribution is not serializable, nor
++ * can the range be arbitrarily reset.
++ *
++ * The implementation also uses different approach than the one taken by
++ * `std::uniform_real_distribution`, where instead of generating a number
++ * between [0, 1) and then multiplying the range bounds with it, we first
++ * split the [a, b] range into a set of equidistributed floating point
++ * numbers, and then use uniform int distribution to pick which one to
++ * return.
++ *
++ * This has the advantage of guaranteeing uniformity (the multiplication
++ * method loses uniformity due to rounding when multiplying floats), except
++ * for small non-uniformity at one side of the interval, where we have
++ * to deal with the fact that not every interval is splittable into
++ * equidistributed floats.
++ *
++ * Based on "Drawing random floating-point numbers from an interval" by
++ * Frederic Goualard.
++ */
++template <typename FloatType>
++class uniform_floating_point_distribution {
++ static_assert(std::is_floating_point<FloatType>::value, "...");
++ static_assert(!std::is_same<FloatType, long double>::value,
++ "We do not support long double due to inconsistent behaviour between platforms");
++
++ using WidthType = Detail::DistanceType<FloatType>;
++
++ FloatType m_a, m_b;
++ FloatType m_ulp_magnitude;
++ WidthType m_floats_in_range;
++ uniform_integer_distribution<WidthType> m_int_dist;
++
++ // In specific cases, we can overflow into `inf` when computing the
++ // `steps * g` offset. To avoid this, we don't offset by more than this
++ // in one multiply + addition.
++ WidthType m_max_steps_in_one_go;
++ // We don't want to do the magnitude check every call to `operator()`
++ bool m_a_has_leq_magnitude;
++
++public:
++ using result_type = FloatType;
++
++ uniform_floating_point_distribution( FloatType a, FloatType b ):
++ m_a( a ),
++ m_b( b ),
++ m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
++ m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
++ m_int_dist(0, m_floats_in_range),
++ m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
++ m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
++ {
++ assert( a <= b );
++ }
++
++ template <typename Generator>
++ result_type operator()( Generator& g ) {
++ WidthType steps = m_int_dist( g );
++ if ( m_a_has_leq_magnitude ) {
++ if ( steps == m_floats_in_range ) { return m_a; }
++ auto b = m_b;
++ while (steps > m_max_steps_in_one_go) {
++ b -= m_max_steps_in_one_go * m_ulp_magnitude;
++ steps -= m_max_steps_in_one_go;
++ }
++ return b - steps * m_ulp_magnitude;
++ } else {
++ if ( steps == m_floats_in_range ) { return m_b; }
++ auto a = m_a;
++ while (steps > m_max_steps_in_one_go) {
++ a += m_max_steps_in_one_go * m_ulp_magnitude;
++ steps -= m_max_steps_in_one_go;
++ }
++ return a + steps * m_ulp_magnitude;
++ }
++ }
++
++ result_type a() const { return m_a; }
++ result_type b() const { return m_b; }
++};
++
++} // end namespace Catch
++
++#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
++
++namespace Catch {
++namespace Generators {
++namespace Detail {
++ // Returns a suitable seed for a random floating generator based off
++ // the primary internal rng. It does so by taking current value from
++ // the rng and returning it as the seed.
++ std::uint32_t getSeed();
++}
++
++template <typename Float>
++class RandomFloatingGenerator final : public IGenerator<Float> {
++ Catch::SimplePcg32 m_rng;
++ Catch::uniform_floating_point_distribution<Float> m_dist;
++ Float m_current_number;
++public:
++ RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
++ m_rng(seed),
++ m_dist(a, b) {
++ static_cast<void>(next());
++ }
++
++ Float const& get() const override {
++ return m_current_number;
++ }
++ bool next() override {
++ m_current_number = m_dist(m_rng);
++ return true;
++ }
++};
++
++template <>
++class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
++ // We still rely on <random> for this specialization, but we don't
++ // want to drag it into the header.
++ struct PImpl;
++ Catch::Detail::unique_ptr<PImpl> m_pimpl;
++ long double m_current_number;
++
++public:
++ RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );
++
++ long double const& get() const override { return m_current_number; }
++ bool next() override;
++
++ ~RandomFloatingGenerator() override; // = default
++};
++
++template <typename Integer>
++class RandomIntegerGenerator final : public IGenerator<Integer> {
++ Catch::SimplePcg32 m_rng;
++ Catch::uniform_integer_distribution<Integer> m_dist;
++ Integer m_current_number;
++public:
++ RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
++ m_rng(seed),
++ m_dist(a, b) {
++ static_cast<void>(next());
++ }
++
++ Integer const& get() const override {
++ return m_current_number;
++ }
++ bool next() override {
++ m_current_number = m_dist(m_rng);
++ return true;
++ }
++};
++
++template <typename T>
++std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
++random(T a, T b) {
++ return GeneratorWrapper<T>(
++ Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
++ );
++}
++
++template <typename T>
++std::enable_if_t<std::is_floating_point<T>::value,
++GeneratorWrapper<T>>
++random(T a, T b) {
++ return GeneratorWrapper<T>(
++ Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
++ );
++}
++
++
++} // namespace Generators
++} // namespace Catch
++
++
++#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
++
++
++#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
++#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
++
++
++#include <iterator>
++#include <type_traits>
++
++namespace Catch {
++namespace Generators {
++
++
++template <typename T>
++class RangeGenerator final : public IGenerator<T> {
++ T m_current;
++ T m_end;
++ T m_step;
++ bool m_positive;
++
++public:
++ RangeGenerator(T const& start, T const& end, T const& step):
++ m_current(start),
++ m_end(end),
++ m_step(step),
++ m_positive(m_step > T(0))
++ {
++ assert(m_current != m_end && "Range start and end cannot be equal");
++ assert(m_step != T(0) && "Step size cannot be zero");
++ assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
++ }
++
++ RangeGenerator(T const& start, T const& end):
++ RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
++ {}
++
++ T const& get() const override {
++ return m_current;
++ }
++
++ bool next() override {
++ m_current += m_step;
++ return (m_positive) ? (m_current < m_end) : (m_current > m_end);
++ }
++};
++
++template <typename T>
++GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
++ static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
++}
++
++template <typename T>
++GeneratorWrapper<T> range(T const& start, T const& end) {
++ static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
++}
++
++
++template <typename T>
++class IteratorGenerator final : public IGenerator<T> {
++ static_assert(!std::is_same<T, bool>::value,
++ "IteratorGenerator currently does not support bools"
++ "because of std::vector<bool> specialization");
++
++ std::vector<T> m_elems;
++ size_t m_current = 0;
++public:
++ template <typename InputIterator, typename InputSentinel>
++ IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
++ if (m_elems.empty()) {
++ Detail::throw_generator_exception("IteratorGenerator received no valid values");
++ }
++ }
++
++ T const& get() const override {
++ return m_elems[m_current];
++ }
++
++ bool next() override {
++ ++m_current;
++ return m_current != m_elems.size();
++ }
++};
++
++template <typename InputIterator,
++ typename InputSentinel,
++ typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
++GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
++ return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
++}
++
++template <typename Container>
++auto from_range(Container const& cnt) {
++ using std::begin;
++ using std::end;
++ return from_range( begin( cnt ), end( cnt ) );
++}
++
++
++} // namespace Generators
++} // namespace Catch
++
++
++#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
++
++#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
++
++
++/** \file
++ * This is a convenience header for Catch2's interfaces. It includes
++ * **all** of Catch2 headers related to interfaces.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of somewhat increased compilation
++ * times.
++ *
++ * When a new header is added to either the `interfaces` folder, or to
++ * the corresponding internal subfolder, it should be added here.
++ */
++
++
++#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
++#define CATCH_INTERFACES_ALL_HPP_INCLUDED
++
++
++
++#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
++#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
++#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
++
++
++namespace Catch {
++
++ struct TestRunInfo {
++ constexpr TestRunInfo(StringRef _name) : name(_name) {}
++ StringRef name;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
++
++#include <map>
++#include <string>
++#include <vector>
++#include <iosfwd>
++
++namespace Catch {
++
++ struct ReporterDescription;
++ struct ListenerDescription;
++ struct TagInfo;
++ struct TestCaseInfo;
++ class TestCaseHandle;
++ class IConfig;
++ class IStream;
++ enum class ColourMode : std::uint8_t;
++
++ struct ReporterConfig {
++ ReporterConfig( IConfig const* _fullConfig,
++ Detail::unique_ptr<IStream> _stream,
++ ColourMode colourMode,
++ std::map<std::string, std::string> customOptions );
++
++ ReporterConfig( ReporterConfig&& ) = default;
++ ReporterConfig& operator=( ReporterConfig&& ) = default;
++ ~ReporterConfig(); // = default
++
++ Detail::unique_ptr<IStream> takeStream() &&;
++ IConfig const* fullConfig() const;
++ ColourMode colourMode() const;
++ std::map<std::string, std::string> const& customOptions() const;
++
++ private:
++ Detail::unique_ptr<IStream> m_stream;
++ IConfig const* m_fullConfig;
++ ColourMode m_colourMode;
++ std::map<std::string, std::string> m_customOptions;
++ };
++
++ struct AssertionStats {
++ AssertionStats( AssertionResult const& _assertionResult,
++ std::vector<MessageInfo> const& _infoMessages,
++ Totals const& _totals );
++
++ AssertionStats( AssertionStats const& ) = default;
++ AssertionStats( AssertionStats && ) = default;
++ AssertionStats& operator = ( AssertionStats const& ) = delete;
++ AssertionStats& operator = ( AssertionStats && ) = delete;
++
++ AssertionResult assertionResult;
++ std::vector<MessageInfo> infoMessages;
++ Totals totals;
++ };
++
++ struct SectionStats {
++ SectionStats( SectionInfo&& _sectionInfo,
++ Counts const& _assertions,
++ double _durationInSeconds,
++ bool _missingAssertions );
++
++ SectionInfo sectionInfo;
++ Counts assertions;
++ double durationInSeconds;
++ bool missingAssertions;
++ };
++
++ struct TestCaseStats {
++ TestCaseStats( TestCaseInfo const& _testInfo,
++ Totals const& _totals,
++ std::string&& _stdOut,
++ std::string&& _stdErr,
++ bool _aborting );
++
++ TestCaseInfo const * testInfo;
++ Totals totals;
++ std::string stdOut;
++ std::string stdErr;
++ bool aborting;
++ };
++
++ struct TestRunStats {
++ TestRunStats( TestRunInfo const& _runInfo,
++ Totals const& _totals,
++ bool _aborting );
++
++ TestRunInfo runInfo;
++ Totals totals;
++ bool aborting;
++ };
++
++ //! By setting up its preferences, a reporter can modify Catch2's behaviour
++ //! in some regards, e.g. it can request Catch2 to capture writes to
++ //! stdout/stderr during test execution, and pass them to the reporter.
++ struct ReporterPreferences {
++ //! Catch2 should redirect writes to stdout and pass them to the
++ //! reporter
++ bool shouldRedirectStdOut = false;
++ //! Catch2 should call `Reporter::assertionEnded` even for passing
++ //! assertions
++ bool shouldReportAllAssertions = false;
++ };
++
++ /**
++ * The common base for all reporters and event listeners
++ *
++ * Implementing classes must also implement:
++ *
++ * //! User-friendly description of the reporter/listener type
++ * static std::string getDescription()
++ *
++ * Generally shouldn't be derived from by users of Catch2 directly,
++ * instead they should derive from one of the utility bases that
++ * derive from this class.
++ */
++ class IEventListener {
++ protected:
++ //! Derived classes can set up their preferences here
++ ReporterPreferences m_preferences;
++ //! The test run's config as filled in from CLI and defaults
++ IConfig const* m_config;
++
++ public:
++ IEventListener( IConfig const* config ): m_config( config ) {}
++
++ virtual ~IEventListener(); // = default;
++
++ // Implementing class must also provide the following static methods:
++ // static std::string getDescription();
++
++ ReporterPreferences const& getPreferences() const {
++ return m_preferences;
++ }
++
++ //! Called when no test cases match provided test spec
++ virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
++ //! Called for all invalid test specs from the cli
++ virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
++
++ /**
++ * Called once in a testing run before tests are started
++ *
++ * Not called if tests won't be run (e.g. only listing will happen)
++ */
++ virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
++
++ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
++ virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
++ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
++ virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
++ //! Called when a `SECTION` is being entered. Not called for skipped sections
++ virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
++
++ //! Called when user-code is being probed before the actual benchmark runs
++ virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
++ //! Called after probe but before the user-code is being benchmarked
++ virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
++ //! Called with the benchmark results if benchmark successfully finishes
++ virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
++ //! Called if running the benchmarks fails for any reason
++ virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
++
++ //! Called before assertion success/failure is evaluated
++ virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
++
++ //! Called after assertion was fully evaluated
++ virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
++
++ //! Called after a `SECTION` has finished running
++ virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
++ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
++ virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
++ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
++ virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
++ /**
++ * Called once after all tests in a testing run are finished
++ *
++ * Not called if tests weren't run (e.g. only listings happened)
++ */
++ virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
++
++ /**
++ * Called with test cases that are skipped due to the test run aborting.
++ * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
++ *
++ * Deprecated - will be removed in the next major release.
++ */
++ virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
++
++ //! Called if a fatal error (signal/structured exception) occurred
++ virtual void fatalErrorEncountered( StringRef error ) = 0;
++
++ //! Writes out information about provided reporters using reporter-specific format
++ virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
++ //! Writes out the provided listeners descriptions using reporter-specific format
++ virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
++ //! Writes out information about provided tests using reporter-specific format
++ virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
++ //! Writes out information about the provided tags using reporter-specific format
++ virtual void listTags(std::vector<TagInfo> const& tags) = 0;
++ };
++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
++
++} // end namespace Catch
++
++#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
++#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ struct ReporterConfig;
++ class IConfig;
++ class IEventListener;
++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
++
++
++ class IReporterFactory {
++ public:
++ virtual ~IReporterFactory(); // = default
++
++ virtual IEventListenerPtr
++ create( ReporterConfig&& config ) const = 0;
++ virtual std::string getDescription() const = 0;
++ };
++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
++
++ class EventListenerFactory {
++ public:
++ virtual ~EventListenerFactory(); // = default
++ virtual IEventListenerPtr create( IConfig const* config ) const = 0;
++ //! Return a meaningful name for the listener, e.g. its type name
++ virtual StringRef getName() const = 0;
++ //! Return listener's description if available
++ virtual std::string getDescription() const = 0;
++ };
++} // namespace Catch
++
++#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ struct TagAlias;
++
++ class ITagAliasRegistry {
++ public:
++ virtual ~ITagAliasRegistry(); // = default
++ // Nullptr if not present
++ virtual TagAlias const* find( std::string const& alias ) const = 0;
++ virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
++
++ static ITagAliasRegistry const& get();
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++
++
++#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
++#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
++
++#include <vector>
++
++namespace Catch {
++
++ struct TestCaseInfo;
++ class TestCaseHandle;
++ class IConfig;
++
++ class ITestCaseRegistry {
++ public:
++ virtual ~ITestCaseRegistry(); // = default
++ // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
++ virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
++ virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
++ virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
++ };
++
++}
++
++#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
++
++#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
++
++
++#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
++#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
++
++
++namespace Catch {
++ namespace Detail {
++ //! Provides case-insensitive `op<` semantics when called
++ struct CaseInsensitiveLess {
++ bool operator()( StringRef lhs,
++ StringRef rhs ) const;
++ };
++
++ //! Provides case-insensitive `op==` semantics when called
++ struct CaseInsensitiveEqualTo {
++ bool operator()( StringRef lhs,
++ StringRef rhs ) const;
++ };
++
++ } // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
++
++
++
++/** \file
++ * Wrapper for ANDROID_LOGWRITE configuration option
++ *
++ * We want to default to enabling it when compiled for android, but
++ * users of the library should also be able to disable it if they want
++ * to.
++ */
++
++#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
++#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
++
++
++#if defined(__ANDROID__)
++# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
++#endif
++
++
++#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
++ !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) && \
++ !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
++# define CATCH_CONFIG_ANDROID_LOGWRITE
++#endif
++
++#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
++
++
++
++/** \file
++ * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
++ *
++ * For some functionality, Catch2 requires to know whether there is
++ * an active exception. Because `std::uncaught_exception` is deprecated
++ * in C++17, we want to use `std::uncaught_exceptions` if possible.
++ */
++
++#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++
++
++#if defined(_MSC_VER)
++# if _MSC_VER >= 1900 // Visual Studio 2015 or newer
++# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
++# endif
++#endif
++
++
++#include <exception>
++
++#if defined(__cpp_lib_uncaught_exceptions) \
++ && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
++
++# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
++#endif // __cpp_lib_uncaught_exceptions
++
++
++#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
++ && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
++ && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
++
++# define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
++#endif
++
++
++#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++
++
++#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
++#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
++
++
++#include <iosfwd>
++#include <cstdint>
++
++namespace Catch {
++
++ enum class ColourMode : std::uint8_t;
++ class IStream;
++
++ struct Colour {
++ enum Code {
++ None = 0,
++
++ White,
++ Red,
++ Green,
++ Blue,
++ Cyan,
++ Yellow,
++ Grey,
++
++ Bright = 0x10,
++
++ BrightRed = Bright | Red,
++ BrightGreen = Bright | Green,
++ LightGrey = Bright | Grey,
++ BrightWhite = Bright | White,
++ BrightYellow = Bright | Yellow,
++
++ // By intention
++ FileName = LightGrey,
++ Warning = BrightYellow,
++ ResultError = BrightRed,
++ ResultSuccess = BrightGreen,
++ ResultExpectedFailure = Warning,
++
++ Error = BrightRed,
++ Success = Green,
++ Skip = LightGrey,
++
++ OriginalExpression = Cyan,
++ ReconstructedExpression = BrightYellow,
++
++ SecondaryText = LightGrey,
++ Headers = White
++ };
++ };
++
++ class ColourImpl {
++ protected:
++ //! The associated stream of this ColourImpl instance
++ IStream* m_stream;
++ public:
++ ColourImpl( IStream* stream ): m_stream( stream ) {}
++
++ //! RAII wrapper around writing specific colour of text using specific
++ //! colour impl into a stream.
++ class ColourGuard {
++ ColourImpl const* m_colourImpl;
++ Colour::Code m_code;
++ bool m_engaged = false;
++
++ public:
++ //! Does **not** engage the guard/start the colour
++ ColourGuard( Colour::Code code,
++ ColourImpl const* colour );
++
++ ColourGuard( ColourGuard const& rhs ) = delete;
++ ColourGuard& operator=( ColourGuard const& rhs ) = delete;
++
++ ColourGuard( ColourGuard&& rhs ) noexcept;
++ ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
++
++ //! Removes colour _if_ the guard was engaged
++ ~ColourGuard();
++
++ /**
++ * Explicitly engages colour for given stream.
++ *
++ * The API based on operator<< should be preferred.
++ */
++ ColourGuard& engage( std::ostream& stream ) &;
++ /**
++ * Explicitly engages colour for given stream.
++ *
++ * The API based on operator<< should be preferred.
++ */
++ ColourGuard&& engage( std::ostream& stream ) &&;
++
++ private:
++ //! Engages the guard and starts using colour
++ friend std::ostream& operator<<( std::ostream& lhs,
++ ColourGuard& guard ) {
++ guard.engageImpl( lhs );
++ return lhs;
++ }
++ //! Engages the guard and starts using colour
++ friend std::ostream& operator<<( std::ostream& lhs,
++ ColourGuard&& guard) {
++ guard.engageImpl( lhs );
++ return lhs;
++ }
++
++ void engageImpl( std::ostream& stream );
++
++ };
++
++ virtual ~ColourImpl(); // = default
++ /**
++ * Creates a guard object for given colour and this colour impl
++ *
++ * **Important:**
++ * the guard starts disengaged, and has to be engaged explicitly.
++ */
++ ColourGuard guardColour( Colour::Code colourCode );
++
++ private:
++ virtual void use( Colour::Code colourCode ) const = 0;
++ };
++
++ //! Provides ColourImpl based on global config and target compilation platform
++ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
++ IStream* stream );
++
++ //! Checks if specific colour impl has been compiled into the binary
++ bool isColourImplAvailable( ColourMode colourSelection );
++
++} // end namespace Catch
++
++#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
++
++
++#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
++#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
++
++// This include must be kept so that user's configured value for CONSOLE_WIDTH
++// is used before we attempt to provide a default value
++
++#ifndef CATCH_CONFIG_CONSOLE_WIDTH
++#define CATCH_CONFIG_CONSOLE_WIDTH 80
++#endif
++
++#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
++
++
++#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
++#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
++
++
++#include <cstddef>
++#include <initializer_list>
++
++// We want a simple polyfill over `std::empty`, `std::size` and so on
++// for C++14 or C++ libraries with incomplete support.
++// We also have to handle that MSVC std lib will happily provide these
++// under older standards.
++#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
++
++// We are already using this header either way, so there shouldn't
++// be much additional overhead in including it to get the feature
++// test macros
++#include <string>
++
++# if !defined(__cpp_lib_nonmember_container_access)
++# define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
++# endif
++
++#else
++#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
++#endif
++
++
++
++namespace Catch {
++namespace Detail {
++
++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
++ template <typename Container>
++ constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
++ return cont.empty();
++ }
++ template <typename T, std::size_t N>
++ constexpr bool empty(const T (&)[N]) noexcept {
++ // GCC < 7 does not support the const T(&)[] parameter syntax
++ // so we have to ignore the length explicitly
++ (void)N;
++ return false;
++ }
++ template <typename T>
++ constexpr bool empty(std::initializer_list<T> list) noexcept {
++ return list.size() > 0;
++ }
++
++
++ template <typename Container>
++ constexpr auto size(Container const& cont) -> decltype(cont.size()) {
++ return cont.size();
++ }
++ template <typename T, std::size_t N>
++ constexpr std::size_t size(const T(&)[N]) noexcept {
++ return N;
++ }
++#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
++
++} // end namespace Detail
++} // end namespace Catch
++
++
++
++#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
++
++
++#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
++#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++ void writeToDebugConsole( std::string const& text );
++}
++
++#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
++
++
++#ifndef CATCH_DEBUGGER_HPP_INCLUDED
++#define CATCH_DEBUGGER_HPP_INCLUDED
++
++
++namespace Catch {
++ bool isDebuggerActive();
++}
++
++#ifdef CATCH_PLATFORM_MAC
++
++ #if defined(__i386__) || defined(__x86_64__)
++ #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
++ #elif defined(__aarch64__)
++ #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
++ #elif defined(__POWERPC__)
++ #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
++ : : : "memory","r0","r3","r4" ) /* NOLINT */
++ #endif
++
++#elif defined(CATCH_PLATFORM_IPHONE)
++
++ // use inline assembler
++ #if defined(__i386__) || defined(__x86_64__)
++ #define CATCH_TRAP() __asm__("int $3")
++ #elif defined(__aarch64__)
++ #define CATCH_TRAP() __asm__(".inst 0xd4200000")
++ #elif defined(__arm__) && !defined(__thumb__)
++ #define CATCH_TRAP() __asm__(".inst 0xe7f001f0")
++ #elif defined(__arm__) && defined(__thumb__)
++ #define CATCH_TRAP() __asm__(".inst 0xde01")
++ #endif
++
++#elif defined(CATCH_PLATFORM_LINUX)
++ // If we can use inline assembler, do it because this allows us to break
++ // directly at the location of the failing check instead of breaking inside
++ // raise() called from it, i.e. one stack frame below.
++ #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
++ #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
++ #else // Fall back to the generic way.
++ #include <signal.h>
++
++ #define CATCH_TRAP() raise(SIGTRAP)
++ #endif
++#elif defined(_MSC_VER)
++ #define CATCH_TRAP() __debugbreak()
++#elif defined(__MINGW32__)
++ extern "C" __declspec(dllimport) void __stdcall DebugBreak();
++ #define CATCH_TRAP() DebugBreak()
++#endif
++
++#ifndef CATCH_BREAK_INTO_DEBUGGER
++ #ifdef CATCH_TRAP
++ #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
++ #else
++ #define CATCH_BREAK_INTO_DEBUGGER() []{}()
++ #endif
++#endif
++
++#endif // CATCH_DEBUGGER_HPP_INCLUDED
++
++
++#ifndef CATCH_ENFORCE_HPP_INCLUDED
++#define CATCH_ENFORCE_HPP_INCLUDED
++
++
++#include <exception>
++
++namespace Catch {
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ template <typename Ex>
++ [[noreturn]]
++ void throw_exception(Ex const& e) {
++ throw e;
++ }
++#else // ^^ Exceptions are enabled // Exceptions are disabled vv
++ [[noreturn]]
++ void throw_exception(std::exception const& e);
++#endif
++
++ [[noreturn]]
++ void throw_logic_error(std::string const& msg);
++ [[noreturn]]
++ void throw_domain_error(std::string const& msg);
++ [[noreturn]]
++ void throw_runtime_error(std::string const& msg);
++
++} // namespace Catch;
++
++#define CATCH_MAKE_MSG(...) \
++ (Catch::ReusableStringStream() << __VA_ARGS__).str()
++
++#define CATCH_INTERNAL_ERROR(...) \
++ Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
++
++#define CATCH_ERROR(...) \
++ Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
++
++#define CATCH_RUNTIME_ERROR(...) \
++ Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
++
++#define CATCH_ENFORCE( condition, ... ) \
++ do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
++
++
++#endif // CATCH_ENFORCE_HPP_INCLUDED
++
++
++#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++
++
++#include <vector>
++
++namespace Catch {
++
++ namespace Detail {
++
++ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
++
++ class EnumValuesRegistry : public IMutableEnumValuesRegistry {
++
++ std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
++
++ EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
++ };
++
++ std::vector<StringRef> parseEnums( StringRef enums );
++
++ } // Detail
++
++} // Catch
++
++#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
++
++
++#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
++#define CATCH_ERRNO_GUARD_HPP_INCLUDED
++
++namespace Catch {
++
++ //! Simple RAII class that stores the value of `errno`
++ //! at construction and restores it at destruction.
++ class ErrnoGuard {
++ public:
++ // Keep these outlined to avoid dragging in macros from <cerrno>
++
++ ErrnoGuard();
++ ~ErrnoGuard();
++ private:
++ int m_oldErrno;
++ };
++
++}
++
++#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
++
++
++#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
++#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
++
++
++#include <vector>
++#include <string>
++
++namespace Catch {
++
++ class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
++ public:
++ ~ExceptionTranslatorRegistry() override;
++ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
++ std::string translateActiveException() const override;
++
++ private:
++ ExceptionTranslators m_translators;
++ };
++}
++
++#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
++
++
++#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
++#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
++
++#include <cassert>
++
++namespace Catch {
++
++ /**
++ * Wrapper for platform-specific fatal error (signals/SEH) handlers
++ *
++ * Tries to be cooperative with other handlers, and not step over
++ * other handlers. This means that unknown structured exceptions
++ * are passed on, previous signal handlers are called, and so on.
++ *
++ * Can only be instantiated once, and assumes that once a signal
++ * is caught, the binary will end up terminating. Thus, there
++ */
++ class FatalConditionHandler {
++ bool m_started = false;
++
++ // Install/disengage implementation for specific platform.
++ // Should be if-defed to work on current platform, can assume
++ // engage-disengage 1:1 pairing.
++ void engage_platform();
++ void disengage_platform() noexcept;
++ public:
++ // Should also have platform-specific implementations as needed
++ FatalConditionHandler();
++ ~FatalConditionHandler();
++
++ void engage() {
++ assert(!m_started && "Handler cannot be installed twice.");
++ m_started = true;
++ engage_platform();
++ }
++
++ void disengage() noexcept {
++ assert(m_started && "Handler cannot be uninstalled without being installed first");
++ m_started = false;
++ disengage_platform();
++ }
++ };
++
++ //! Simple RAII guard for (dis)engaging the FatalConditionHandler
++ class FatalConditionHandlerGuard {
++ FatalConditionHandler* m_handler;
++ public:
++ FatalConditionHandlerGuard(FatalConditionHandler* handler):
++ m_handler(handler) {
++ m_handler->engage();
++ }
++ ~FatalConditionHandlerGuard() {
++ m_handler->disengage();
++ }
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
++
++
++#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
++#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
++
++
++#include <cassert>
++#include <cmath>
++#include <cstdint>
++#include <utility>
++#include <limits>
++
++namespace Catch {
++ namespace Detail {
++
++ uint32_t convertToBits(float f);
++ uint64_t convertToBits(double d);
++
++ // Used when we know we want == comparison of two doubles
++ // to centralize warning suppression
++ bool directCompare( float lhs, float rhs );
++ bool directCompare( double lhs, double rhs );
++
++ } // end namespace Detail
++
++
++
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic push
++ // We do a bunch of direct compensations of floating point numbers,
++ // because we know what we are doing and actually do want the direct
++ // comparison behaviour.
++# pragma GCC diagnostic ignored "-Wfloat-equal"
++#endif
++
++ /**
++ * Calculates the ULP distance between two floating point numbers
++ *
++ * The ULP distance of two floating point numbers is the count of
++ * valid floating point numbers representable between them.
++ *
++ * There are some exceptions between how this function counts the
++ * distance, and the interpretation of the standard as implemented.
++ * by e.g. `nextafter`. For this function it always holds that:
++ * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
++ * * `ulpDistance(maxFinite, INF) == 1`
++ * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
++ *
++ * \pre `!isnan( lhs )`
++ * \pre `!isnan( rhs )`
++ * \pre floating point numbers are represented in IEEE-754 format
++ */
++ template <typename FP>
++ uint64_t ulpDistance( FP lhs, FP rhs ) {
++ assert( std::numeric_limits<FP>::is_iec559 &&
++ "ulpDistance assumes IEEE-754 format for floating point types" );
++ assert( !Catch::isnan( lhs ) &&
++ "Distance between NaN and number is not meaningful" );
++ assert( !Catch::isnan( rhs ) &&
++ "Distance between NaN and number is not meaningful" );
++
++ // We want X == Y to imply 0 ULP distance even if X and Y aren't
++ // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
++ if ( lhs == rhs ) { return 0; }
++
++ // We need a properly typed positive zero for type inference.
++ static constexpr FP positive_zero{};
++
++ // We want to ensure that +/- 0 is always represented as positive zero
++ if ( lhs == positive_zero ) { lhs = positive_zero; }
++ if ( rhs == positive_zero ) { rhs = positive_zero; }
++
++ // If arguments have different signs, we can handle them by summing
++ // how far are they from 0 each.
++ if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
++ return ulpDistance( std::abs( lhs ), positive_zero ) +
++ ulpDistance( std::abs( rhs ), positive_zero );
++ }
++
++ // When both lhs and rhs are of the same sign, we can just
++ // read the numbers bitwise as integers, and then subtract them
++ // (assuming IEEE).
++ uint64_t lc = Detail::convertToBits( lhs );
++ uint64_t rc = Detail::convertToBits( rhs );
++
++ // The ulp distance between two numbers is symmetric, so to avoid
++ // dealing with overflows we want the bigger converted number on the lhs
++ if ( lc < rc ) {
++ std::swap( lc, rc );
++ }
++
++ return lc - rc;
++ }
++
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic pop
++#endif
++
++
++} // end namespace Catch
++
++#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
++
++
++#ifndef CATCH_GETENV_HPP_INCLUDED
++#define CATCH_GETENV_HPP_INCLUDED
++
++namespace Catch {
++namespace Detail {
++
++ //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
++ char const* getEnv(char const* varName);
++
++}
++}
++
++#endif // CATCH_GETENV_HPP_INCLUDED
++
++
++#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
++#define CATCH_IS_PERMUTATION_HPP_INCLUDED
++
++#include <algorithm>
++#include <iterator>
++
++namespace Catch {
++ namespace Detail {
++
++ template <typename ForwardIter,
++ typename Sentinel,
++ typename T,
++ typename Comparator>
++ ForwardIter find_sentinel( ForwardIter start,
++ Sentinel sentinel,
++ T const& value,
++ Comparator cmp ) {
++ while ( start != sentinel ) {
++ if ( cmp( *start, value ) ) { break; }
++ ++start;
++ }
++ return start;
++ }
++
++ template <typename ForwardIter,
++ typename Sentinel,
++ typename T,
++ typename Comparator>
++ std::ptrdiff_t count_sentinel( ForwardIter start,
++ Sentinel sentinel,
++ T const& value,
++ Comparator cmp ) {
++ std::ptrdiff_t count = 0;
++ while ( start != sentinel ) {
++ if ( cmp( *start, value ) ) { ++count; }
++ ++start;
++ }
++ return count;
++ }
++
++ template <typename ForwardIter, typename Sentinel>
++ std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
++ std::ptrdiff_t>
++ sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
++ std::ptrdiff_t dist = 0;
++ while ( iter != sentinel ) {
++ ++iter;
++ ++dist;
++ }
++ return dist;
++ }
++
++ template <typename ForwardIter>
++ std::ptrdiff_t sentinel_distance( ForwardIter first,
++ ForwardIter last ) {
++ return std::distance( first, last );
++ }
++
++ template <typename ForwardIter1,
++ typename Sentinel1,
++ typename ForwardIter2,
++ typename Sentinel2,
++ typename Comparator>
++ bool check_element_counts( ForwardIter1 first_1,
++ const Sentinel1 end_1,
++ ForwardIter2 first_2,
++ const Sentinel2 end_2,
++ Comparator cmp ) {
++ auto cursor = first_1;
++ while ( cursor != end_1 ) {
++ if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
++ cursor ) {
++ // we haven't checked this element yet
++ const auto count_in_range_2 =
++ count_sentinel( first_2, end_2, *cursor, cmp );
++ // Not a single instance in 2nd range, so it cannot be a
++ // permutation of 1st range
++ if ( count_in_range_2 == 0 ) { return false; }
++
++ const auto count_in_range_1 =
++ count_sentinel( cursor, end_1, *cursor, cmp );
++ if ( count_in_range_1 != count_in_range_2 ) {
++ return false;
++ }
++ }
++
++ ++cursor;
++ }
++
++ return true;
++ }
++
++ template <typename ForwardIter1,
++ typename Sentinel1,
++ typename ForwardIter2,
++ typename Sentinel2,
++ typename Comparator>
++ bool is_permutation( ForwardIter1 first_1,
++ const Sentinel1 end_1,
++ ForwardIter2 first_2,
++ const Sentinel2 end_2,
++ Comparator cmp ) {
++ // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
++ // TODO: Comparator has to be "both sides", e.g. a == b => b == a
++ // This skips shared prefix of the two ranges
++ while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
++ ++first_1;
++ ++first_2;
++ }
++
++ // We need to handle case where at least one of the ranges has no more elements
++ if (first_1 == end_1 || first_2 == end_2) {
++ return first_1 == end_1 && first_2 == end_2;
++ }
++
++ // pair counting is n**2, so we pay linear walk to compare the sizes first
++ auto dist_1 = sentinel_distance( first_1, end_1 );
++ auto dist_2 = sentinel_distance( first_2, end_2 );
++
++ if (dist_1 != dist_2) { return false; }
++
++ // Since we do not try to handle stronger iterators pair (e.g.
++ // bidir) optimally, the only thing left to do is to check counts in
++ // the remaining ranges.
++ return check_element_counts( first_1, end_1, first_2, end_2, cmp );
++ }
++
++ } // namespace Detail
++} // namespace Catch
++
++#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
++
++
++#ifndef CATCH_ISTREAM_HPP_INCLUDED
++#define CATCH_ISTREAM_HPP_INCLUDED
++
++
++#include <iosfwd>
++#include <cstddef>
++#include <ostream>
++#include <string>
++
++namespace Catch {
++
++ class IStream {
++ public:
++ virtual ~IStream(); // = default
++ virtual std::ostream& stream() = 0;
++ /**
++ * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
++ *
++ * This is useful for e.g. Win32 colour support, because the Win32
++ * API manipulates console directly, unlike POSIX escape codes,
++ * that can be written anywhere.
++ *
++ * Due to variety of ways to change where the stdout/stderr is
++ * _actually_ being written, users should always assume that
++ * the answer might be wrong.
++ */
++ virtual bool isConsole() const { return false; }
++ };
++
++ /**
++ * Creates a stream wrapper that writes to specific file.
++ *
++ * Also recognizes 4 special filenames
++ * * `-` for stdout
++ * * `%stdout` for stdout
++ * * `%stderr` for stderr
++ * * `%debug` for platform specific debugging output
++ *
++ * \throws if passed an unrecognized %-prefixed stream
++ */
++ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
++
++}
++
++#endif // CATCH_STREAM_HPP_INCLUDED
++
++
++#ifndef CATCH_JSONWRITER_HPP_INCLUDED
++#define CATCH_JSONWRITER_HPP_INCLUDED
++
++
++#include <cstdint>
++#include <sstream>
++
++namespace Catch {
++ class JsonObjectWriter;
++ class JsonArrayWriter;
++
++ struct JsonUtils {
++ static void indent( std::ostream& os, std::uint64_t level );
++ static void appendCommaNewline( std::ostream& os,
++ bool& should_comma,
++ std::uint64_t level );
++ };
++
++ class JsonValueWriter {
++ public:
++ JsonValueWriter( std::ostream& os );
++ JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
++
++ JsonObjectWriter writeObject() &&;
++ JsonArrayWriter writeArray() &&;
++
++ template <typename T>
++ void write( T const& value ) && {
++ writeImpl( value, !std::is_arithmetic<T>::value );
++ }
++ void write( StringRef value ) &&;
++ void write( bool value ) &&;
++
++ private:
++ void writeImpl( StringRef value, bool quote );
++
++ // Without this SFINAE, this overload is a better match
++ // for `std::string`, `char const*`, `char const[N]` args.
++ // While it would still work, it would cause code bloat
++ // and multiple iteration over the strings
++ template <typename T,
++ typename = typename std::enable_if_t<
++ !std::is_convertible<T, StringRef>::value>>
++ void writeImpl( T const& value, bool quote_value ) {
++ m_sstream << value;
++ writeImpl( m_sstream.str(), quote_value );
++ }
++
++ std::ostream& m_os;
++ std::stringstream m_sstream;
++ std::uint64_t m_indent_level;
++ };
++
++ class JsonObjectWriter {
++ public:
++ JsonObjectWriter( std::ostream& os );
++ JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
++
++ JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
++ JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;
++
++ ~JsonObjectWriter();
++
++ JsonValueWriter write( StringRef key );
++
++ private:
++ std::ostream& m_os;
++ std::uint64_t m_indent_level;
++ bool m_should_comma = false;
++ bool m_active = true;
++ };
++
++ class JsonArrayWriter {
++ public:
++ JsonArrayWriter( std::ostream& os );
++ JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
++
++ JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
++ JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;
++
++ ~JsonArrayWriter();
++
++ JsonObjectWriter writeObject();
++ JsonArrayWriter writeArray();
++
++ template <typename T>
++ JsonArrayWriter& write( T const& value ) {
++ return writeImpl( value );
++ }
++
++ JsonArrayWriter& write( bool value );
++
++ private:
++ template <typename T>
++ JsonArrayWriter& writeImpl( T const& value ) {
++ JsonUtils::appendCommaNewline(
++ m_os, m_should_comma, m_indent_level + 1 );
++ JsonValueWriter{ m_os }.write( value );
++
++ return *this;
++ }
++
++ std::ostream& m_os;
++ std::uint64_t m_indent_level;
++ bool m_should_comma = false;
++ bool m_active = true;
++ };
++
++} // namespace Catch
++
++#endif // CATCH_JSONWRITER_HPP_INCLUDED
++
++
++#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
++#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
++
++namespace Catch {
++
++ struct LeakDetector {
++ LeakDetector();
++ ~LeakDetector();
++ };
++
++}
++#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
++
++
++#ifndef CATCH_LIST_HPP_INCLUDED
++#define CATCH_LIST_HPP_INCLUDED
++
++
++#include <set>
++#include <string>
++
++
++namespace Catch {
++
++ class IEventListener;
++ class Config;
++
++
++ struct ReporterDescription {
++ std::string name, description;
++ };
++ struct ListenerDescription {
++ StringRef name;
++ std::string description;
++ };
++
++ struct TagInfo {
++ void add(StringRef spelling);
++ std::string all() const;
++
++ std::set<StringRef> spellings;
++ std::size_t count = 0;
++ };
++
++ bool list( IEventListener& reporter, Config const& config );
++
++} // end namespace Catch
++
++#endif // CATCH_LIST_HPP_INCLUDED
++
++
++#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
++#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
++
++
++#include <cstdio>
++#include <iosfwd>
++#include <string>
++
++namespace Catch {
++
++ class RedirectedStream {
++ std::ostream& m_originalStream;
++ std::ostream& m_redirectionStream;
++ std::streambuf* m_prevBuf;
++
++ public:
++ RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
++ ~RedirectedStream();
++ };
++
++ class RedirectedStdOut {
++ ReusableStringStream m_rss;
++ RedirectedStream m_cout;
++ public:
++ RedirectedStdOut();
++ auto str() const -> std::string;
++ };
++
++ // StdErr has two constituent streams in C++, std::cerr and std::clog
++ // This means that we need to redirect 2 streams into 1 to keep proper
++ // order of writes
++ class RedirectedStdErr {
++ ReusableStringStream m_rss;
++ RedirectedStream m_cerr;
++ RedirectedStream m_clog;
++ public:
++ RedirectedStdErr();
++ auto str() const -> std::string;
++ };
++
++ class RedirectedStreams {
++ public:
++ RedirectedStreams(RedirectedStreams const&) = delete;
++ RedirectedStreams& operator=(RedirectedStreams const&) = delete;
++ RedirectedStreams(RedirectedStreams&&) = delete;
++ RedirectedStreams& operator=(RedirectedStreams&&) = delete;
++
++ RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
++ ~RedirectedStreams();
++ private:
++ std::string& m_redirectedCout;
++ std::string& m_redirectedCerr;
++ RedirectedStdOut m_redirectedStdOut;
++ RedirectedStdErr m_redirectedStdErr;
++ };
++
++#if defined(CATCH_CONFIG_NEW_CAPTURE)
++
++ // Windows's implementation of std::tmpfile is terrible (it tries
++ // to create a file inside system folder, thus requiring elevated
++ // privileges for the binary), so we have to use tmpnam(_s) and
++ // create the file ourselves there.
++ class TempFile {
++ public:
++ TempFile(TempFile const&) = delete;
++ TempFile& operator=(TempFile const&) = delete;
++ TempFile(TempFile&&) = delete;
++ TempFile& operator=(TempFile&&) = delete;
++
++ TempFile();
++ ~TempFile();
++
++ std::FILE* getFile();
++ std::string getContents();
++
++ private:
++ std::FILE* m_file = nullptr;
++ #if defined(_MSC_VER)
++ char m_buffer[L_tmpnam] = { 0 };
++ #endif
++ };
++
++
++ class OutputRedirect {
++ public:
++ OutputRedirect(OutputRedirect const&) = delete;
++ OutputRedirect& operator=(OutputRedirect const&) = delete;
++ OutputRedirect(OutputRedirect&&) = delete;
++ OutputRedirect& operator=(OutputRedirect&&) = delete;
++
++
++ OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
++ ~OutputRedirect();
++
++ private:
++ int m_originalStdout = -1;
++ int m_originalStderr = -1;
++ TempFile m_stdoutFile;
++ TempFile m_stderrFile;
++ std::string& m_stdoutDest;
++ std::string& m_stderrDest;
++ };
++
++#endif
++
++} // end namespace Catch
++
++#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
++
++
++#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
++#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++ /**
++ * Parses unsigned int from the input, using provided base
++ *
++ * Effectively a wrapper around std::stoul but with better error checking
++ * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
++ */
++ Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
++}
++
++#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
++#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
++
++
++#include <map>
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ class IEventListener;
++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
++ class IReporterFactory;
++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
++ struct ReporterConfig;
++ class EventListenerFactory;
++
++ class ReporterRegistry {
++ struct ReporterRegistryImpl;
++ Detail::unique_ptr<ReporterRegistryImpl> m_impl;
++
++ public:
++ ReporterRegistry();
++ ~ReporterRegistry(); // = default;
++
++ IEventListenerPtr create( std::string const& name,
++ ReporterConfig&& config ) const;
++
++ void registerReporter( std::string const& name,
++ IReporterFactoryPtr factory );
++
++ void
++ registerListener( Detail::unique_ptr<EventListenerFactory> factory );
++
++ std::map<std::string,
++ IReporterFactoryPtr,
++ Detail::CaseInsensitiveLess> const&
++ getFactories() const;
++
++ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
++ getListeners() const;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
++
++
++#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
++#define CATCH_RUN_CONTEXT_HPP_INCLUDED
++
++
++
++#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
++#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
++
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++namespace TestCaseTracking {
++
++ struct NameAndLocation {
++ std::string name;
++ SourceLineInfo location;
++
++ NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
++ friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
++ // This is a very cheap check that should have a very high hit rate.
++ // If we get to SourceLineInfo::operator==, we will redo it, but the
++ // cost of repeating is trivial at that point (we will be paying
++ // multiple strcmp/memcmps at that point).
++ if ( lhs.location.line != rhs.location.line ) { return false; }
++ return lhs.name == rhs.name && lhs.location == rhs.location;
++ }
++ friend bool operator!=(NameAndLocation const& lhs,
++ NameAndLocation const& rhs) {
++ return !( lhs == rhs );
++ }
++ };
++
++ /**
++ * This is a variant of `NameAndLocation` that does not own the name string
++ *
++ * This avoids extra allocations when trying to locate a tracker by its
++ * name and location, as long as we make sure that trackers only keep
++ * around the owning variant.
++ */
++ struct NameAndLocationRef {
++ StringRef name;
++ SourceLineInfo location;
++
++ constexpr NameAndLocationRef( StringRef name_,
++ SourceLineInfo location_ ):
++ name( name_ ), location( location_ ) {}
++
++ friend bool operator==( NameAndLocation const& lhs,
++ NameAndLocationRef const& rhs ) {
++ // This is a very cheap check that should have a very high hit rate.
++ // If we get to SourceLineInfo::operator==, we will redo it, but the
++ // cost of repeating is trivial at that point (we will be paying
++ // multiple strcmp/memcmps at that point).
++ if ( lhs.location.line != rhs.location.line ) { return false; }
++ return StringRef( lhs.name ) == rhs.name &&
++ lhs.location == rhs.location;
++ }
++ friend bool operator==( NameAndLocationRef const& lhs,
++ NameAndLocation const& rhs ) {
++ return rhs == lhs;
++ }
++ };
++
++ class ITracker;
++
++ using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
++
++ class ITracker {
++ NameAndLocation m_nameAndLocation;
++
++ using Children = std::vector<ITrackerPtr>;
++
++ protected:
++ enum CycleState {
++ NotStarted,
++ Executing,
++ ExecutingChildren,
++ NeedsAnotherRun,
++ CompletedSuccessfully,
++ Failed
++ };
++
++ ITracker* m_parent = nullptr;
++ Children m_children;
++ CycleState m_runState = NotStarted;
++
++ public:
++ ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
++ m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
++ m_parent( parent )
++ {}
++
++
++ // static queries
++ NameAndLocation const& nameAndLocation() const {
++ return m_nameAndLocation;
++ }
++ ITracker* parent() const {
++ return m_parent;
++ }
++
++ virtual ~ITracker(); // = default
++
++
++ // dynamic queries
++
++ //! Returns true if tracker run to completion (successfully or not)
++ virtual bool isComplete() const = 0;
++ //! Returns true if tracker run to completion successfully
++ bool isSuccessfullyCompleted() const {
++ return m_runState == CompletedSuccessfully;
++ }
++ //! Returns true if tracker has started but hasn't been completed
++ bool isOpen() const;
++ //! Returns true iff tracker has started
++ bool hasStarted() const;
++
++ // actions
++ virtual void close() = 0; // Successfully complete
++ virtual void fail() = 0;
++ void markAsNeedingAnotherRun();
++
++ //! Register a nested ITracker
++ void addChild( ITrackerPtr&& child );
++ /**
++ * Returns ptr to specific child if register with this tracker.
++ *
++ * Returns nullptr if not found.
++ */
++ ITracker* findChild( NameAndLocationRef const& nameAndLocation );
++ //! Have any children been added?
++ bool hasChildren() const {
++ return !m_children.empty();
++ }
++
++
++ //! Marks tracker as executing a child, doing se recursively up the tree
++ void openChild();
++
++ /**
++ * Returns true if the instance is a section tracker
++ *
++ * Subclasses should override to true if they are, replaces RTTI
++ * for internal debug checks.
++ */
++ virtual bool isSectionTracker() const;
++ /**
++ * Returns true if the instance is a generator tracker
++ *
++ * Subclasses should override to true if they are, replaces RTTI
++ * for internal debug checks.
++ */
++ virtual bool isGeneratorTracker() const;
++ };
++
++ class TrackerContext {
++
++ enum RunState {
++ NotStarted,
++ Executing,
++ CompletedCycle
++ };
++
++ ITrackerPtr m_rootTracker;
++ ITracker* m_currentTracker = nullptr;
++ RunState m_runState = NotStarted;
++
++ public:
++
++ ITracker& startRun();
++
++ void startCycle() {
++ m_currentTracker = m_rootTracker.get();
++ m_runState = Executing;
++ }
++ void completeCycle();
++
++ bool completedCycle() const;
++ ITracker& currentTracker() { return *m_currentTracker; }
++ void setCurrentTracker( ITracker* tracker );
++ };
++
++ class TrackerBase : public ITracker {
++ protected:
++
++ TrackerContext& m_ctx;
++
++ public:
++ TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
++
++ bool isComplete() const override;
++
++ void open();
++
++ void close() override;
++ void fail() override;
++
++ private:
++ void moveToParent();
++ void moveToThis();
++ };
++
++ class SectionTracker : public TrackerBase {
++ std::vector<StringRef> m_filters;
++ // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
++ // Currently it allocates owns the name, so this is safe. If it is later refactored
++ // to not own the name, the name still has to outlive the `ITracker` parent, so
++ // this should still be safe.
++ StringRef m_trimmed_name;
++ public:
++ SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
++
++ bool isSectionTracker() const override;
++
++ bool isComplete() const override;
++
++ static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
++
++ void tryOpen();
++
++ void addInitialFilters( std::vector<std::string> const& filters );
++ void addNextFilters( std::vector<StringRef> const& filters );
++ //! Returns filters active in this tracker
++ std::vector<StringRef> const& getFilters() const { return m_filters; }
++ //! Returns whitespace-trimmed name of the tracked section
++ StringRef trimmedName() const;
++ };
++
++} // namespace TestCaseTracking
++
++using TestCaseTracking::ITracker;
++using TestCaseTracking::TrackerContext;
++using TestCaseTracking::SectionTracker;
++
++} // namespace Catch
++
++#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ class IGeneratorTracker;
++ class IConfig;
++ class IEventListener;
++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ class RunContext final : public IResultCapture {
++
++ public:
++ RunContext( RunContext const& ) = delete;
++ RunContext& operator =( RunContext const& ) = delete;
++
++ explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
++
++ ~RunContext() override;
++
++ Totals runTest(TestCaseHandle const& testCase);
++
++ public: // IResultCapture
++
++ // Assertion handlers
++ void handleExpr
++ ( AssertionInfo const& info,
++ ITransientExpression const& expr,
++ AssertionReaction& reaction ) override;
++ void handleMessage
++ ( AssertionInfo const& info,
++ ResultWas::OfType resultType,
++ StringRef message,
++ AssertionReaction& reaction ) override;
++ void handleUnexpectedExceptionNotThrown
++ ( AssertionInfo const& info,
++ AssertionReaction& reaction ) override;
++ void handleUnexpectedInflightException
++ ( AssertionInfo const& info,
++ std::string&& message,
++ AssertionReaction& reaction ) override;
++ void handleIncomplete
++ ( AssertionInfo const& info ) override;
++ void handleNonExpr
++ ( AssertionInfo const &info,
++ ResultWas::OfType resultType,
++ AssertionReaction &reaction ) override;
++
++ void notifyAssertionStarted( AssertionInfo const& info ) override;
++ bool sectionStarted( StringRef sectionName,
++ SourceLineInfo const& sectionLineInfo,
++ Counts& assertions ) override;
++
++ void sectionEnded( SectionEndInfo&& endInfo ) override;
++ void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
++
++ IGeneratorTracker*
++ acquireGeneratorTracker( StringRef generatorName,
++ SourceLineInfo const& lineInfo ) override;
++ IGeneratorTracker* createGeneratorTracker(
++ StringRef generatorName,
++ SourceLineInfo lineInfo,
++ Generators::GeneratorBasePtr&& generator ) override;
++
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting( BenchmarkInfo const& info ) override;
++ void benchmarkEnded( BenchmarkStats<> const& stats ) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void pushScopedMessage( MessageInfo const& message ) override;
++ void popScopedMessage( MessageInfo const& message ) override;
++
++ void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
++
++ std::string getCurrentTestName() const override;
++
++ const AssertionResult* getLastResult() const override;
++
++ void exceptionEarlyReported() override;
++
++ void handleFatalErrorCondition( StringRef message ) override;
++
++ bool lastAssertionPassed() override;
++
++ void assertionPassed() override;
++
++ public:
++ // !TBD We need to do this another way!
++ bool aborting() const;
++
++ private:
++
++ void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
++ void invokeActiveTestCase();
++
++ void resetAssertionInfo();
++ bool testForMissingAssertions( Counts& assertions );
++
++ void assertionEnded( AssertionResult&& result );
++ void reportExpr
++ ( AssertionInfo const &info,
++ ResultWas::OfType resultType,
++ ITransientExpression const *expr,
++ bool negated );
++
++ void populateReaction( AssertionReaction& reaction );
++
++ private:
++
++ void handleUnfinishedSections();
++
++ TestRunInfo m_runInfo;
++ TestCaseHandle const* m_activeTestCase = nullptr;
++ ITracker* m_testCaseTracker = nullptr;
++ Optional<AssertionResult> m_lastResult;
++
++ IConfig const* m_config;
++ Totals m_totals;
++ IEventListenerPtr m_reporter;
++ std::vector<MessageInfo> m_messages;
++ std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
++ AssertionInfo m_lastAssertionInfo;
++ std::vector<SectionEndInfo> m_unfinishedSections;
++ std::vector<ITracker*> m_activeSections;
++ TrackerContext m_trackerContext;
++ FatalConditionHandler m_fatalConditionhandler;
++ bool m_lastAssertionPassed = false;
++ bool m_shouldReportUnexpected = true;
++ bool m_includeSuccessfulResults;
++ };
++
++ void seedRng(IConfig const& config);
++ unsigned int rngSeed();
++} // end namespace Catch
++
++#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
++
++
++#ifndef CATCH_SHARDING_HPP_INCLUDED
++#define CATCH_SHARDING_HPP_INCLUDED
++
++#include <cassert>
++#include <cmath>
++#include <algorithm>
++
++namespace Catch {
++
++ template<typename Container>
++ Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
++ assert(shardCount > shardIndex);
++
++ if (shardCount == 1) {
++ return container;
++ }
++
++ const std::size_t totalTestCount = container.size();
++
++ const std::size_t shardSize = totalTestCount / shardCount;
++ const std::size_t leftoverTests = totalTestCount % shardCount;
++
++ const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
++ const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
++
++ auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
++ auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
++
++ return Container(startIterator, endIterator);
++ }
++
++}
++
++#endif // CATCH_SHARDING_HPP_INCLUDED
++
++
++#ifndef CATCH_SINGLETONS_HPP_INCLUDED
++#define CATCH_SINGLETONS_HPP_INCLUDED
++
++namespace Catch {
++
++ struct ISingleton {
++ virtual ~ISingleton(); // = default
++ };
++
++
++ void addSingleton( ISingleton* singleton );
++ void cleanupSingletons();
++
++
++ template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
++ class Singleton : SingletonImplT, public ISingleton {
++
++ static auto getInternal() -> Singleton* {
++ static Singleton* s_instance = nullptr;
++ if( !s_instance ) {
++ s_instance = new Singleton;
++ addSingleton( s_instance );
++ }
++ return s_instance;
++ }
++
++ public:
++ static auto get() -> InterfaceT const& {
++ return *getInternal();
++ }
++ static auto getMutable() -> MutableInterfaceT& {
++ return *getInternal();
++ }
++ };
++
++} // namespace Catch
++
++#endif // CATCH_SINGLETONS_HPP_INCLUDED
++
++
++#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
++#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
++
++
++#include <vector>
++#include <exception>
++
++namespace Catch {
++
++ class StartupExceptionRegistry {
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ public:
++ void add(std::exception_ptr const& exception) noexcept;
++ std::vector<std::exception_ptr> const& getExceptions() const noexcept;
++ private:
++ std::vector<std::exception_ptr> m_exceptions;
++#endif
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
++
++
++
++#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
++#define CATCH_STDSTREAMS_HPP_INCLUDED
++
++#include <iosfwd>
++
++namespace Catch {
++
++ std::ostream& cout();
++ std::ostream& cerr();
++ std::ostream& clog();
++
++} // namespace Catch
++
++#endif
++
++
++#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
++#define CATCH_STRING_MANIP_HPP_INCLUDED
++
++
++#include <cstdint>
++#include <string>
++#include <iosfwd>
++#include <vector>
++
++namespace Catch {
++
++ bool startsWith( std::string const& s, std::string const& prefix );
++ bool startsWith( StringRef s, char prefix );
++ bool endsWith( std::string const& s, std::string const& suffix );
++ bool endsWith( std::string const& s, char suffix );
++ bool contains( std::string const& s, std::string const& infix );
++ void toLowerInPlace( std::string& s );
++ std::string toLower( std::string const& s );
++ char toLower( char c );
++ //! Returns a new string without whitespace at the start/end
++ std::string trim( std::string const& str );
++ //! Returns a substring of the original ref without whitespace. Beware lifetimes!
++ StringRef trim(StringRef ref);
++
++ // !!! Be aware, returns refs into original string - make sure original string outlives them
++ std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
++ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
++
++ /**
++ * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
++ *
++ * Usage example:
++ * ```cpp
++ * std::cout << "Found " << pluralise(count, "error") << '\n';
++ * ```
++ *
++ * **Important:** The provided string must outlive the instance
++ */
++ class pluralise {
++ std::uint64_t m_count;
++ StringRef m_label;
++
++ public:
++ constexpr pluralise(std::uint64_t count, StringRef label):
++ m_count(count),
++ m_label(label)
++ {}
++
++ friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
++ };
++}
++
++#endif // CATCH_STRING_MANIP_HPP_INCLUDED
++
++
++#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++
++
++#include <map>
++#include <string>
++
++namespace Catch {
++ struct SourceLineInfo;
++
++ class TagAliasRegistry : public ITagAliasRegistry {
++ public:
++ ~TagAliasRegistry() override;
++ TagAlias const* find( std::string const& alias ) const override;
++ std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
++ void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
++
++ private:
++ std::map<std::string, TagAlias> m_registry;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
++
++
++#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
++#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
++
++#include <cstdint>
++
++namespace Catch {
++
++ struct TestCaseInfo;
++
++ class TestCaseInfoHasher {
++ public:
++ using hash_t = std::uint64_t;
++ TestCaseInfoHasher( hash_t seed );
++ uint32_t operator()( TestCaseInfo const& t ) const;
++
++ private:
++ hash_t m_seed;
++ };
++
++} // namespace Catch
++
++#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
++
++
++#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
++#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
++
++
++#include <vector>
++
++namespace Catch {
++
++ class IConfig;
++ class ITestInvoker;
++ class TestCaseHandle;
++ class TestSpec;
++
++ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
++
++ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
++
++ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
++ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
++
++ class TestRegistry : public ITestCaseRegistry {
++ public:
++ void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
++
++ std::vector<TestCaseInfo*> const& getAllInfos() const override;
++ std::vector<TestCaseHandle> const& getAllTests() const override;
++ std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
++
++ ~TestRegistry() override; // = default
++
++ private:
++ std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
++ // Keeps a materialized vector for `getAllInfos`.
++ // We should get rid of that eventually (see interface note)
++ std::vector<TestCaseInfo*> m_viewed_test_infos;
++
++ std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
++ std::vector<TestCaseHandle> m_handles;
++ mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
++ mutable std::vector<TestCaseHandle> m_sortedFunctions;
++ };
++
++ ///////////////////////////////////////////////////////////////////////////
++
++
++} // end namespace Catch
++
++
++#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
++
++
++#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
++#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
++
++#ifdef __clang__
++#pragma clang diagnostic push
++#pragma clang diagnostic ignored "-Wpadded"
++#endif
++
++
++#include <vector>
++#include <string>
++
++namespace Catch {
++
++ class ITagAliasRegistry;
++
++ class TestSpecParser {
++ enum Mode{ None, Name, QuotedName, Tag, EscapedName };
++ Mode m_mode = None;
++ Mode lastMode = None;
++ bool m_exclusion = false;
++ std::size_t m_pos = 0;
++ std::size_t m_realPatternPos = 0;
++ std::string m_arg;
++ std::string m_substring;
++ std::string m_patternName;
++ std::vector<std::size_t> m_escapeChars;
++ TestSpec::Filter m_currentFilter;
++ TestSpec m_testSpec;
++ ITagAliasRegistry const* m_tagAliases = nullptr;
++
++ public:
++ TestSpecParser( ITagAliasRegistry const& tagAliases );
++
++ TestSpecParser& parse( std::string const& arg );
++ TestSpec testSpec();
++
++ private:
++ bool visitChar( char c );
++ void startNewMode( Mode mode );
++ bool processNoneChar( char c );
++ void processNameChar( char c );
++ bool processOtherChar( char c );
++ void endMode();
++ void escape();
++ bool isControlChar( char c ) const;
++ void saveLastMode();
++ void revertBackToLastMode();
++ void addFilter();
++ bool separate();
++
++ // Handles common preprocessing of the pattern for name/tag patterns
++ std::string preprocessPattern();
++ // Adds the current pattern as a test name
++ void addNamePattern();
++ // Adds the current pattern as a tag
++ void addTagPattern();
++
++ inline void addCharToPattern(char c) {
++ m_substring += c;
++ m_patternName += c;
++ m_realPatternPos++;
++ }
++
++ };
++
++} // namespace Catch
++
++#ifdef __clang__
++#pragma clang diagnostic pop
++#endif
++
++#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
++
++
++#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
++#define CATCH_TEXTFLOW_HPP_INCLUDED
++
++
++#include <cassert>
++#include <string>
++#include <vector>
++
++namespace Catch {
++ namespace TextFlow {
++
++ class Columns;
++
++ /**
++ * Abstraction for a string with ansi escape sequences that
++ * automatically skips over escapes when iterating. Only graphical
++ * escape sequences are considered.
++ *
++ * Internal representation:
++ * An escape sequence looks like \033[39;49m
++ * We need bidirectional iteration and the unbound length of escape
++ * sequences poses a problem for operator-- To make this work we'll
++ * replace the last `m` with a 0xff (this is a codepoint that won't have
++ * any utf-8 meaning).
++ */
++ class AnsiSkippingString {
++ std::string m_string;
++ std::size_t m_size = 0;
++
++ // perform 0xff replacement and calculate m_size
++ void preprocessString();
++
++ public:
++ class const_iterator;
++ using iterator = const_iterator;
++ // note: must be u-suffixed or this will cause a "truncation of
++ // constant value" warning on MSVC
++ static constexpr char sentinel = static_cast<char>( 0xffu );
++
++ explicit AnsiSkippingString( std::string const& text );
++ explicit AnsiSkippingString( std::string&& text );
++
++ const_iterator begin() const;
++ const_iterator end() const;
++
++ size_t size() const { return m_size; }
++
++ std::string substring( const_iterator begin,
++ const_iterator end ) const;
++ };
++
++ class AnsiSkippingString::const_iterator {
++ friend AnsiSkippingString;
++ struct EndTag {};
++
++ const std::string* m_string;
++ std::string::const_iterator m_it;
++
++ explicit const_iterator( const std::string& string, EndTag ):
++ m_string( &string ), m_it( string.end() ) {}
++
++ void tryParseAnsiEscapes();
++ void advance();
++ void unadvance();
++
++ public:
++ using difference_type = std::ptrdiff_t;
++ using value_type = char;
++ using pointer = value_type*;
++ using reference = value_type&;
++ using iterator_category = std::bidirectional_iterator_tag;
++
++ explicit const_iterator( const std::string& string ):
++ m_string( &string ), m_it( string.begin() ) {
++ tryParseAnsiEscapes();
++ }
++
++ char operator*() const { return *m_it; }
++
++ const_iterator& operator++() {
++ advance();
++ return *this;
++ }
++ const_iterator operator++( int ) {
++ iterator prev( *this );
++ operator++();
++ return prev;
++ }
++ const_iterator& operator--() {
++ unadvance();
++ return *this;
++ }
++ const_iterator operator--( int ) {
++ iterator prev( *this );
++ operator--();
++ return prev;
++ }
++
++ bool operator==( const_iterator const& other ) const {
++ return m_it == other.m_it;
++ }
++ bool operator!=( const_iterator const& other ) const {
++ return !operator==( other );
++ }
++ bool operator<=( const_iterator const& other ) const {
++ return m_it <= other.m_it;
++ }
++
++ const_iterator oneBefore() const {
++ auto it = *this;
++ return --it;
++ }
++ };
++
++ /**
++ * Represents a column of text with specific width and indentation
++ *
++ * When written out to a stream, it will perform linebreaking
++ * of the provided text so that the written lines fit within
++ * target width.
++ */
++ class Column {
++ // String to be written out
++ AnsiSkippingString m_string;
++ // Width of the column for linebreaking
++ size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
++ // Indentation of other lines (including first if initial indent is
++ // unset)
++ size_t m_indent = 0;
++ // Indentation of the first line
++ size_t m_initialIndent = std::string::npos;
++
++ public:
++ /**
++ * Iterates "lines" in `Column` and returns them
++ */
++ class const_iterator {
++ friend Column;
++ struct EndTag {};
++
++ Column const& m_column;
++ // Where does the current line start?
++ AnsiSkippingString::const_iterator m_lineStart;
++ // How long should the current line be?
++ AnsiSkippingString::const_iterator m_lineEnd;
++ // How far have we checked the string to iterate?
++ AnsiSkippingString::const_iterator m_parsedTo;
++ // Should a '-' be appended to the line?
++ bool m_addHyphen = false;
++
++ const_iterator( Column const& column, EndTag ):
++ m_column( column ),
++ m_lineStart( m_column.m_string.end() ),
++ m_lineEnd( column.m_string.end() ),
++ m_parsedTo( column.m_string.end() ) {}
++
++ // Calculates the length of the current line
++ void calcLength();
++
++ // Returns current indentation width
++ size_t indentSize() const;
++
++ // Creates an indented and (optionally) suffixed string from
++ // current iterator position, indentation and length.
++ std::string addIndentAndSuffix(
++ AnsiSkippingString::const_iterator start,
++ AnsiSkippingString::const_iterator end ) const;
++
++ public:
++ using difference_type = std::ptrdiff_t;
++ using value_type = std::string;
++ using pointer = value_type*;
++ using reference = value_type&;
++ using iterator_category = std::forward_iterator_tag;
++
++ explicit const_iterator( Column const& column );
++
++ std::string operator*() const;
++
++ const_iterator& operator++();
++ const_iterator operator++( int );
++
++ bool operator==( const_iterator const& other ) const {
++ return m_lineStart == other.m_lineStart &&
++ &m_column == &other.m_column;
++ }
++ bool operator!=( const_iterator const& other ) const {
++ return !operator==( other );
++ }
++ };
++ using iterator = const_iterator;
++
++ explicit Column( std::string const& text ): m_string( text ) {}
++ explicit Column( std::string&& text ):
++ m_string( CATCH_MOVE( text ) ) {}
++
++ Column& width( size_t newWidth ) & {
++ assert( newWidth > 0 );
++ m_width = newWidth;
++ return *this;
++ }
++ Column&& width( size_t newWidth ) && {
++ assert( newWidth > 0 );
++ m_width = newWidth;
++ return CATCH_MOVE( *this );
++ }
++ Column& indent( size_t newIndent ) & {
++ m_indent = newIndent;
++ return *this;
++ }
++ Column&& indent( size_t newIndent ) && {
++ m_indent = newIndent;
++ return CATCH_MOVE( *this );
++ }
++ Column& initialIndent( size_t newIndent ) & {
++ m_initialIndent = newIndent;
++ return *this;
++ }
++ Column&& initialIndent( size_t newIndent ) && {
++ m_initialIndent = newIndent;
++ return CATCH_MOVE( *this );
++ }
++
++ size_t width() const { return m_width; }
++ const_iterator begin() const { return const_iterator( *this ); }
++ const_iterator end() const {
++ return { *this, const_iterator::EndTag{} };
++ }
++
++ friend std::ostream& operator<<( std::ostream& os,
++ Column const& col );
++
++ friend Columns operator+( Column const& lhs, Column const& rhs );
++ friend Columns operator+( Column&& lhs, Column&& rhs );
++ };
++
++ //! Creates a column that serves as an empty space of specific width
++ Column Spacer( size_t spaceWidth );
++
++ class Columns {
++ std::vector<Column> m_columns;
++
++ public:
++ class iterator {
++ friend Columns;
++ struct EndTag {};
++
++ std::vector<Column> const& m_columns;
++ std::vector<Column::const_iterator> m_iterators;
++ size_t m_activeIterators;
++
++ iterator( Columns const& columns, EndTag );
++
++ public:
++ using difference_type = std::ptrdiff_t;
++ using value_type = std::string;
++ using pointer = value_type*;
++ using reference = value_type&;
++ using iterator_category = std::forward_iterator_tag;
++
++ explicit iterator( Columns const& columns );
++
++ auto operator==( iterator const& other ) const -> bool {
++ return m_iterators == other.m_iterators;
++ }
++ auto operator!=( iterator const& other ) const -> bool {
++ return m_iterators != other.m_iterators;
++ }
++ std::string operator*() const;
++ iterator& operator++();
++ iterator operator++( int );
++ };
++ using const_iterator = iterator;
++
++ iterator begin() const { return iterator( *this ); }
++ iterator end() const { return { *this, iterator::EndTag() }; }
++
++ friend Columns& operator+=( Columns& lhs, Column const& rhs );
++ friend Columns& operator+=( Columns& lhs, Column&& rhs );
++ friend Columns operator+( Columns const& lhs, Column const& rhs );
++ friend Columns operator+( Columns&& lhs, Column&& rhs );
++
++ friend std::ostream& operator<<( std::ostream& os,
++ Columns const& cols );
++ };
++
++ } // namespace TextFlow
++} // namespace Catch
++#endif // CATCH_TEXTFLOW_HPP_INCLUDED
++
++
++#ifndef CATCH_TO_STRING_HPP_INCLUDED
++#define CATCH_TO_STRING_HPP_INCLUDED
++
++#include <string>
++
++
++namespace Catch {
++ template <typename T>
++ std::string to_string(T const& t) {
++#if defined(CATCH_CONFIG_CPP11_TO_STRING)
++ return std::to_string(t);
++#else
++ ReusableStringStream rss;
++ rss << t;
++ return rss.str();
++#endif
++ }
++} // end namespace Catch
++
++#endif // CATCH_TO_STRING_HPP_INCLUDED
++
++
++#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++
++namespace Catch {
++ bool uncaught_exceptions();
++} // end namespace Catch
++
++#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
++
++
++#ifndef CATCH_XMLWRITER_HPP_INCLUDED
++#define CATCH_XMLWRITER_HPP_INCLUDED
++
++
++#include <iosfwd>
++#include <vector>
++
++namespace Catch {
++ enum class XmlFormatting {
++ None = 0x00,
++ Indent = 0x01,
++ Newline = 0x02,
++ };
++
++ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
++ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
++
++ /**
++ * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
++ *
++ * Note: doesn't take ownership of passed strings, and thus the
++ * encoded string must outlive the encoding instance.
++ */
++ class XmlEncode {
++ public:
++ enum ForWhat { ForTextNodes, ForAttributes };
++
++ XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
++
++ void encodeTo( std::ostream& os ) const;
++
++ friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
++
++ private:
++ StringRef m_str;
++ ForWhat m_forWhat;
++ };
++
++ class XmlWriter {
++ public:
++
++ class ScopedElement {
++ public:
++ ScopedElement( XmlWriter* writer, XmlFormatting fmt );
++
++ ScopedElement( ScopedElement&& other ) noexcept;
++ ScopedElement& operator=( ScopedElement&& other ) noexcept;
++
++ ~ScopedElement();
++
++ ScopedElement&
++ writeText( StringRef text,
++ XmlFormatting fmt = XmlFormatting::Newline |
++ XmlFormatting::Indent );
++
++ ScopedElement& writeAttribute( StringRef name,
++ StringRef attribute );
++ template <typename T,
++ // Without this SFINAE, this overload is a better match
++ // for `std::string`, `char const*`, `char const[N]` args.
++ // While it would still work, it would cause code bloat
++ // and multiple iteration over the strings
++ typename = typename std::enable_if_t<
++ !std::is_convertible<T, StringRef>::value>>
++ ScopedElement& writeAttribute( StringRef name,
++ T const& attribute ) {
++ m_writer->writeAttribute( name, attribute );
++ return *this;
++ }
++
++ private:
++ XmlWriter* m_writer = nullptr;
++ XmlFormatting m_fmt;
++ };
++
++ XmlWriter( std::ostream& os );
++ ~XmlWriter();
++
++ XmlWriter( XmlWriter const& ) = delete;
++ XmlWriter& operator=( XmlWriter const& ) = delete;
++
++ XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
++
++ ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
++
++ XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
++
++ //! The attribute content is XML-encoded
++ XmlWriter& writeAttribute( StringRef name, StringRef attribute );
++
++ //! Writes the attribute as "true/false"
++ XmlWriter& writeAttribute( StringRef name, bool attribute );
++
++ //! The attribute content is XML-encoded
++ XmlWriter& writeAttribute( StringRef name, char const* attribute );
++
++ //! The attribute value must provide op<<(ostream&, T). The resulting
++ //! serialization is XML-encoded
++ template <typename T,
++ // Without this SFINAE, this overload is a better match
++ // for `std::string`, `char const*`, `char const[N]` args.
++ // While it would still work, it would cause code bloat
++ // and multiple iteration over the strings
++ typename = typename std::enable_if_t<
++ !std::is_convertible<T, StringRef>::value>>
++ XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
++ ReusableStringStream rss;
++ rss << attribute;
++ return writeAttribute( name, rss.str() );
++ }
++
++ //! Writes escaped `text` in a element
++ XmlWriter& writeText( StringRef text,
++ XmlFormatting fmt = XmlFormatting::Newline |
++ XmlFormatting::Indent );
++
++ //! Writes XML comment as "<!-- text -->"
++ XmlWriter& writeComment( StringRef text,
++ XmlFormatting fmt = XmlFormatting::Newline |
++ XmlFormatting::Indent );
++
++ void writeStylesheetRef( StringRef url );
++
++ void ensureTagClosed();
++
++ private:
++
++ void applyFormatting(XmlFormatting fmt);
++
++ void writeDeclaration();
++
++ void newlineIfNecessary();
++
++ bool m_tagIsOpen = false;
++ bool m_needsNewline = false;
++ std::vector<std::string> m_tags;
++ std::string m_indent;
++ std::ostream& m_os;
++ };
++
++}
++
++#endif // CATCH_XMLWRITER_HPP_INCLUDED
++
++
++/** \file
++ * This is a convenience header for Catch2's Matcher support. It includes
++ * **all** of Catch2 headers related to matchers.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of increased compilation times.
++ *
++ * When a new header is added to either the `matchers` folder, or to
++ * the corresponding internal subfolder, it should be added here.
++ */
++
++#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
++#define CATCH_MATCHERS_ALL_HPP_INCLUDED
++
++
++
++#ifndef CATCH_MATCHERS_HPP_INCLUDED
++#define CATCH_MATCHERS_HPP_INCLUDED
++
++
++
++#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
++#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++
++#ifdef __clang__
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wsign-compare"
++# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
++#elif defined __GNUC__
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wsign-compare"
++# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
++#endif
++
++ template<typename ArgT, typename MatcherT>
++ class MatchExpr : public ITransientExpression {
++ ArgT && m_arg;
++ MatcherT const& m_matcher;
++ public:
++ MatchExpr( ArgT && arg, MatcherT const& matcher )
++ : ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
++ m_arg( CATCH_FORWARD(arg) ),
++ m_matcher( matcher )
++ {}
++
++ void streamReconstructedExpression( std::ostream& os ) const override {
++ os << Catch::Detail::stringify( m_arg )
++ << ' '
++ << m_matcher.toString();
++ }
++ };
++
++#ifdef __clang__
++# pragma clang diagnostic pop
++#elif defined __GNUC__
++# pragma GCC diagnostic pop
++#endif
++
++
++ namespace Matchers {
++ template <typename ArgT>
++ class MatcherBase;
++ }
++
++ using StringMatcher = Matchers::MatcherBase<std::string>;
++
++ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
++
++ template<typename ArgT, typename MatcherT>
++ auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
++ return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
++ }
++
++} // namespace Catch
++
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
++ INTERNAL_CATCH_TRY { \
++ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
++ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++
++///////////////////////////////////////////////////////////////////////////////
++#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
++ do { \
++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
++ if( catchAssertionHandler.allowThrows() ) \
++ try { \
++ static_cast<void>(__VA_ARGS__ ); \
++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
++ } \
++ catch( exceptionType const& ex ) { \
++ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
++ } \
++ catch( ... ) { \
++ catchAssertionHandler.handleUnexpectedInflightException(); \
++ } \
++ else \
++ catchAssertionHandler.handleThrowingCallSkipped(); \
++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
++ } while( false )
++
++
++#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++namespace Matchers {
++
++ class MatcherUntypedBase {
++ public:
++ MatcherUntypedBase() = default;
++
++ MatcherUntypedBase(MatcherUntypedBase const&) = default;
++ MatcherUntypedBase(MatcherUntypedBase&&) = default;
++
++ MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
++ MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
++
++ std::string toString() const;
++
++ protected:
++ virtual ~MatcherUntypedBase(); // = default;
++ virtual std::string describe() const = 0;
++ mutable std::string m_cachedToString;
++ };
++
++
++ template<typename T>
++ class MatcherBase : public MatcherUntypedBase {
++ public:
++ virtual bool match( T const& arg ) const = 0;
++ };
++
++ namespace Detail {
++
++ template<typename ArgT>
++ class MatchAllOf final : public MatcherBase<ArgT> {
++ std::vector<MatcherBase<ArgT> const*> m_matchers;
++
++ public:
++ MatchAllOf() = default;
++ MatchAllOf(MatchAllOf const&) = delete;
++ MatchAllOf& operator=(MatchAllOf const&) = delete;
++ MatchAllOf(MatchAllOf&&) = default;
++ MatchAllOf& operator=(MatchAllOf&&) = default;
++
++
++ bool match( ArgT const& arg ) const override {
++ for( auto matcher : m_matchers ) {
++ if (!matcher->match(arg))
++ return false;
++ }
++ return true;
++ }
++ std::string describe() const override {
++ std::string description;
++ description.reserve( 4 + m_matchers.size()*32 );
++ description += "( ";
++ bool first = true;
++ for( auto matcher : m_matchers ) {
++ if( first )
++ first = false;
++ else
++ description += " and ";
++ description += matcher->toString();
++ }
++ description += " )";
++ return description;
++ }
++
++ friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
++ lhs.m_matchers.push_back(&rhs);
++ return CATCH_MOVE(lhs);
++ }
++ friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
++ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
++ return CATCH_MOVE(rhs);
++ }
++ };
++
++ //! lvalue overload is intentionally deleted, users should
++ //! not be trying to compose stored composition matchers
++ template<typename ArgT>
++ MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
++ //! lvalue overload is intentionally deleted, users should
++ //! not be trying to compose stored composition matchers
++ template<typename ArgT>
++ MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
++
++ template<typename ArgT>
++ class MatchAnyOf final : public MatcherBase<ArgT> {
++ std::vector<MatcherBase<ArgT> const*> m_matchers;
++ public:
++ MatchAnyOf() = default;
++ MatchAnyOf(MatchAnyOf const&) = delete;
++ MatchAnyOf& operator=(MatchAnyOf const&) = delete;
++ MatchAnyOf(MatchAnyOf&&) = default;
++ MatchAnyOf& operator=(MatchAnyOf&&) = default;
++
++ bool match( ArgT const& arg ) const override {
++ for( auto matcher : m_matchers ) {
++ if (matcher->match(arg))
++ return true;
++ }
++ return false;
++ }
++ std::string describe() const override {
++ std::string description;
++ description.reserve( 4 + m_matchers.size()*32 );
++ description += "( ";
++ bool first = true;
++ for( auto matcher : m_matchers ) {
++ if( first )
++ first = false;
++ else
++ description += " or ";
++ description += matcher->toString();
++ }
++ description += " )";
++ return description;
++ }
++
++ friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
++ lhs.m_matchers.push_back(&rhs);
++ return CATCH_MOVE(lhs);
++ }
++ friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
++ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
++ return CATCH_MOVE(rhs);
++ }
++ };
++
++ //! lvalue overload is intentionally deleted, users should
++ //! not be trying to compose stored composition matchers
++ template<typename ArgT>
++ MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
++ //! lvalue overload is intentionally deleted, users should
++ //! not be trying to compose stored composition matchers
++ template<typename ArgT>
++ MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
++
++ template<typename ArgT>
++ class MatchNotOf final : public MatcherBase<ArgT> {
++ MatcherBase<ArgT> const& m_underlyingMatcher;
++
++ public:
++ explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
++ m_underlyingMatcher( underlyingMatcher )
++ {}
++
++ bool match( ArgT const& arg ) const override {
++ return !m_underlyingMatcher.match( arg );
++ }
++
++ std::string describe() const override {
++ return "not " + m_underlyingMatcher.toString();
++ }
++ };
++
++ } // namespace Detail
++
++ template <typename T>
++ Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
++ return Detail::MatchAllOf<T>{} && lhs && rhs;
++ }
++ template <typename T>
++ Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
++ return Detail::MatchAnyOf<T>{} || lhs || rhs;
++ }
++
++ template <typename T>
++ Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
++ return Detail::MatchNotOf<T>{ matcher };
++ }
++
++
++} // namespace Matchers
++} // namespace Catch
++
++
++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
++ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
++ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
++
++ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
++ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
++
++ #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
++ #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
++
++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
++
++ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
++ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
++
++ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) (void)(0)
++ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
++
++ #define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
++ #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
++
++ #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
++ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
++
++ #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
++ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
++
++ #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
++ #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
++
++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
++
++ #define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
++ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
++
++ #define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
++ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
++
++ #define CHECK_THAT( arg, matcher ) (void)(0)
++ #define REQUIRE_THAT( arg, matcher ) (void)(0)
++
++#endif // end of user facing macro declarations
++
++#endif // CATCH_MATCHERS_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
++#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
++
++
++
++#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
++#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
++
++
++#include <array>
++#include <algorithm>
++#include <string>
++#include <type_traits>
++
++namespace Catch {
++namespace Matchers {
++ class MatcherGenericBase : public MatcherUntypedBase {
++ public:
++ MatcherGenericBase() = default;
++ ~MatcherGenericBase() override; // = default;
++
++ MatcherGenericBase(MatcherGenericBase const&) = default;
++ MatcherGenericBase(MatcherGenericBase&&) = default;
++
++ MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
++ MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
++ };
++
++
++ namespace Detail {
++ template<std::size_t N, std::size_t M>
++ std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
++ std::array<void const*, N + M> arr{};
++ std::copy_n(lhs.begin(), N, arr.begin());
++ std::copy_n(rhs.begin(), M, arr.begin() + N);
++ return arr;
++ }
++
++ template<std::size_t N>
++ std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
++ std::array<void const*, N+1> arr{};
++ std::copy_n(lhs.begin(), N, arr.begin());
++ arr[N] = rhs;
++ return arr;
++ }
++
++ template<std::size_t N>
++ std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
++ std::array<void const*, N + 1> arr{ {lhs} };
++ std::copy_n(rhs.begin(), N, arr.begin() + 1);
++ return arr;
++ }
++
++ template<typename T>
++ using is_generic_matcher = std::is_base_of<
++ Catch::Matchers::MatcherGenericBase,
++ std::remove_cv_t<std::remove_reference_t<T>>
++ >;
++
++ template<typename... Ts>
++ using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
++
++ template<typename T>
++ using is_matcher = std::is_base_of<
++ Catch::Matchers::MatcherUntypedBase,
++ std::remove_cv_t<std::remove_reference_t<T>>
++ >;
++
++
++ template<std::size_t N, typename Arg>
++ bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
++ return true;
++ }
++
++ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
++ bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
++ return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
++ }
++
++
++ template<std::size_t N, typename Arg>
++ bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
++ return false;
++ }
++
++ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
++ bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
++ return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
++ }
++
++ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
++
++ template<typename... MatcherTs, std::size_t... Idx>
++ std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
++ std::array<std::string, sizeof...(MatcherTs)> descriptions {{
++ static_cast<MatcherTs const*>(matchers[Idx])->toString()...
++ }};
++
++ return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
++ }
++
++
++ template<typename... MatcherTs>
++ class MatchAllOfGeneric final : public MatcherGenericBase {
++ public:
++ MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
++ MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
++ MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
++ MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
++
++ MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
++ explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
++
++ template<typename Arg>
++ bool match(Arg&& arg) const {
++ return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
++ }
++
++ std::string describe() const override {
++ return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
++ }
++
++ // Has to be public to enable the concatenating operators
++ // below, because they are not friend of the RHS, only LHS,
++ // and thus cannot access private fields of RHS
++ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
++
++
++ //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
++ template<typename... MatchersRHS>
++ friend
++ MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
++ MatchAllOfGeneric<MatcherTs...>&& lhs,
++ MatchAllOfGeneric<MatchersRHS...>&& rhs) {
++ return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
++ }
++
++ //! Avoids type nesting for `GenericAllOf && some matcher` case
++ template<typename MatcherRHS>
++ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
++ MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
++ MatchAllOfGeneric<MatcherTs...>&& lhs,
++ MatcherRHS const& rhs) {
++ return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
++ }
++
++ //! Avoids type nesting for `some matcher && GenericAllOf` case
++ template<typename MatcherLHS>
++ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
++ MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
++ MatcherLHS const& lhs,
++ MatchAllOfGeneric<MatcherTs...>&& rhs) {
++ return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
++ }
++ };
++
++
++ template<typename... MatcherTs>
++ class MatchAnyOfGeneric final : public MatcherGenericBase {
++ public:
++ MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
++ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
++ MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
++ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
++
++ MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
++ explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
++
++ template<typename Arg>
++ bool match(Arg&& arg) const {
++ return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
++ }
++
++ std::string describe() const override {
++ return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
++ }
++
++
++ // Has to be public to enable the concatenating operators
++ // below, because they are not friend of the RHS, only LHS,
++ // and thus cannot access private fields of RHS
++ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
++
++ //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
++ template<typename... MatchersRHS>
++ friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
++ MatchAnyOfGeneric<MatcherTs...>&& lhs,
++ MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
++ return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
++ }
++
++ //! Avoids type nesting for `GenericAnyOf || some matcher` case
++ template<typename MatcherRHS>
++ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
++ MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
++ MatchAnyOfGeneric<MatcherTs...>&& lhs,
++ MatcherRHS const& rhs) {
++ return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
++ }
++
++ //! Avoids type nesting for `some matcher || GenericAnyOf` case
++ template<typename MatcherLHS>
++ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
++ MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
++ MatcherLHS const& lhs,
++ MatchAnyOfGeneric<MatcherTs...>&& rhs) {
++ return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
++ }
++ };
++
++
++ template<typename MatcherT>
++ class MatchNotOfGeneric final : public MatcherGenericBase {
++ MatcherT const& m_matcher;
++
++ public:
++ MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
++ MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
++ MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
++ MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
++
++ explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
++
++ template<typename Arg>
++ bool match(Arg&& arg) const {
++ return !m_matcher.match(arg);
++ }
++
++ std::string describe() const override {
++ return "not " + m_matcher.toString();
++ }
++
++ //! Negating negation can just unwrap and return underlying matcher
++ friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
++ return matcher.m_matcher;
++ }
++ };
++ } // namespace Detail
++
++
++ // compose only generic matchers
++ template<typename MatcherLHS, typename MatcherRHS>
++ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
++ operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
++ return { lhs, rhs };
++ }
++
++ template<typename MatcherLHS, typename MatcherRHS>
++ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
++ operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
++ return { lhs, rhs };
++ }
++
++ //! Wrap provided generic matcher in generic negator
++ template<typename MatcherT>
++ std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
++ operator ! (MatcherT const& matcher) {
++ return Detail::MatchNotOfGeneric<MatcherT>{matcher};
++ }
++
++
++ // compose mixed generic and non-generic matchers
++ template<typename MatcherLHS, typename ArgRHS>
++ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
++ operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
++ return { lhs, rhs };
++ }
++
++ template<typename ArgLHS, typename MatcherRHS>
++ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
++ operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
++ return { lhs, rhs };
++ }
++
++ template<typename MatcherLHS, typename ArgRHS>
++ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
++ operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
++ return { lhs, rhs };
++ }
++
++ template<typename ArgLHS, typename MatcherRHS>
++ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
++ operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
++ return { lhs, rhs };
++ }
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
++
++namespace Catch {
++ namespace Matchers {
++
++ class IsEmptyMatcher final : public MatcherGenericBase {
++ public:
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
++ using Catch::Detail::empty;
++#else
++ using std::empty;
++#endif
++ return empty(rng);
++ }
++
++ std::string describe() const override;
++ };
++
++ class HasSizeMatcher final : public MatcherGenericBase {
++ std::size_t m_target_size;
++ public:
++ explicit HasSizeMatcher(std::size_t target_size):
++ m_target_size(target_size)
++ {}
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
++ using Catch::Detail::size;
++#else
++ using std::size;
++#endif
++ return size(rng) == m_target_size;
++ }
++
++ std::string describe() const override;
++ };
++
++ template <typename Matcher>
++ class SizeMatchesMatcher final : public MatcherGenericBase {
++ Matcher m_matcher;
++ public:
++ explicit SizeMatchesMatcher(Matcher m):
++ m_matcher(CATCH_MOVE(m))
++ {}
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
++ using Catch::Detail::size;
++#else
++ using std::size;
++#endif
++ return m_matcher.match(size(rng));
++ }
++
++ std::string describe() const override {
++ return "size matches " + m_matcher.describe();
++ }
++ };
++
++
++ //! Creates a matcher that accepts empty ranges/containers
++ IsEmptyMatcher IsEmpty();
++ //! Creates a matcher that accepts ranges/containers with specific size
++ HasSizeMatcher SizeIs(std::size_t sz);
++ template <typename Matcher>
++ std::enable_if_t<Detail::is_matcher<Matcher>::value,
++ SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
++ return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
++ }
++
++ } // end namespace Matchers
++} // end namespace Catch
++
++#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
++#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
++
++
++#include <algorithm>
++#include <functional>
++
++namespace Catch {
++ namespace Matchers {
++ //! Matcher for checking that an element in range is equal to specific element
++ template <typename T, typename Equality>
++ class ContainsElementMatcher final : public MatcherGenericBase {
++ T m_desired;
++ Equality m_eq;
++ public:
++ template <typename T2, typename Equality2>
++ ContainsElementMatcher(T2&& target, Equality2&& predicate):
++ m_desired(CATCH_FORWARD(target)),
++ m_eq(CATCH_FORWARD(predicate))
++ {}
++
++ std::string describe() const override {
++ return "contains element " + Catch::Detail::stringify(m_desired);
++ }
++
++ template <typename RangeLike>
++ bool match( RangeLike&& rng ) const {
++ for ( auto&& elem : rng ) {
++ if ( m_eq( elem, m_desired ) ) { return true; }
++ }
++ return false;
++ }
++ };
++
++ //! Meta-matcher for checking that an element in a range matches a specific matcher
++ template <typename Matcher>
++ class ContainsMatcherMatcher final : public MatcherGenericBase {
++ Matcher m_matcher;
++ public:
++ // Note that we do a copy+move to avoid having to SFINAE this
++ // constructor (and also avoid some perfect forwarding failure
++ // cases)
++ ContainsMatcherMatcher(Matcher matcher):
++ m_matcher(CATCH_MOVE(matcher))
++ {}
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (m_matcher.match(elem)) {
++ return true;
++ }
++ }
++ return false;
++ }
++
++ std::string describe() const override {
++ return "contains element matching " + m_matcher.describe();
++ }
++ };
++
++ /**
++ * Creates a matcher that checks whether a range contains a specific element.
++ *
++ * Uses `std::equal_to` to do the comparison
++ */
++ template <typename T>
++ std::enable_if_t<!Detail::is_matcher<T>::value,
++ ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
++ return { CATCH_FORWARD(elem), std::equal_to<>{} };
++ }
++
++ //! Creates a matcher that checks whether a range contains element matching a matcher
++ template <typename Matcher>
++ std::enable_if_t<Detail::is_matcher<Matcher>::value,
++ ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
++ return { CATCH_FORWARD(matcher) };
++ }
++
++ /**
++ * Creates a matcher that checks whether a range contains a specific element.
++ *
++ * Uses `eq` to do the comparisons, the element is provided on the rhs
++ */
++ template <typename T, typename Equality>
++ ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
++ return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
++ }
++
++ }
++}
++
++#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
++#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
++
++
++namespace Catch {
++namespace Matchers {
++
++class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
++ std::string m_message;
++public:
++
++ ExceptionMessageMatcher(std::string const& message):
++ m_message(message)
++ {}
++
++ bool match(std::exception const& ex) const override;
++
++ std::string describe() const override;
++};
++
++//! Creates a matcher that checks whether a std derived exception has the provided message
++ExceptionMessageMatcher Message(std::string const& message);
++
++template <typename StringMatcherType>
++class ExceptionMessageMatchesMatcher final
++ : public MatcherBase<std::exception> {
++ StringMatcherType m_matcher;
++
++public:
++ ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
++ m_matcher( CATCH_MOVE( matcher ) ) {}
++
++ bool match( std::exception const& ex ) const override {
++ return m_matcher.match( ex.what() );
++ }
++
++ std::string describe() const override {
++ return " matches \"" + m_matcher.describe() + '"';
++ }
++};
++
++//! Creates a matcher that checks whether a message from an std derived
++//! exception matches a provided matcher
++template <typename StringMatcherType>
++ExceptionMessageMatchesMatcher<StringMatcherType>
++MessageMatches( StringMatcherType&& matcher ) {
++ return { CATCH_FORWARD( matcher ) };
++}
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
++#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
++
++
++namespace Catch {
++namespace Matchers {
++
++ namespace Detail {
++ enum class FloatingPointKind : uint8_t;
++ }
++
++ class WithinAbsMatcher final : public MatcherBase<double> {
++ public:
++ WithinAbsMatcher(double target, double margin);
++ bool match(double const& matchee) const override;
++ std::string describe() const override;
++ private:
++ double m_target;
++ double m_margin;
++ };
++
++ //! Creates a matcher that accepts numbers within certain range of target
++ WithinAbsMatcher WithinAbs( double target, double margin );
++
++
++
++ class WithinUlpsMatcher final : public MatcherBase<double> {
++ public:
++ WithinUlpsMatcher( double target,
++ uint64_t ulps,
++ Detail::FloatingPointKind baseType );
++ bool match(double const& matchee) const override;
++ std::string describe() const override;
++ private:
++ double m_target;
++ uint64_t m_ulps;
++ Detail::FloatingPointKind m_type;
++ };
++
++ //! Creates a matcher that accepts doubles within certain ULP range of target
++ WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
++ //! Creates a matcher that accepts floats within certain ULP range of target
++ WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
++
++
++
++ // Given IEEE-754 format for floats and doubles, we can assume
++ // that float -> double promotion is lossless. Given this, we can
++ // assume that if we do the standard relative comparison of
++ // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
++ // the same result if we do this for floats, as if we do this for
++ // doubles that were promoted from floats.
++ class WithinRelMatcher final : public MatcherBase<double> {
++ public:
++ WithinRelMatcher( double target, double epsilon );
++ bool match(double const& matchee) const override;
++ std::string describe() const override;
++ private:
++ double m_target;
++ double m_epsilon;
++ };
++
++ //! Creates a matcher that accepts doubles within certain relative range of target
++ WithinRelMatcher WithinRel(double target, double eps);
++ //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
++ WithinRelMatcher WithinRel(double target);
++ //! Creates a matcher that accepts doubles within certain relative range of target
++ WithinRelMatcher WithinRel(float target, float eps);
++ //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
++ WithinRelMatcher WithinRel(float target);
++
++
++
++ class IsNaNMatcher final : public MatcherBase<double> {
++ public:
++ IsNaNMatcher() = default;
++ bool match( double const& matchee ) const override;
++ std::string describe() const override;
++ };
++
++ IsNaNMatcher IsNaN();
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
++#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++namespace Matchers {
++
++namespace Detail {
++ std::string finalizeDescription(const std::string& desc);
++} // namespace Detail
++
++template <typename T, typename Predicate>
++class PredicateMatcher final : public MatcherBase<T> {
++ Predicate m_predicate;
++ std::string m_description;
++public:
++
++ PredicateMatcher(Predicate&& elem, std::string const& descr)
++ :m_predicate(CATCH_FORWARD(elem)),
++ m_description(Detail::finalizeDescription(descr))
++ {}
++
++ bool match( T const& item ) const override {
++ return m_predicate(item);
++ }
++
++ std::string describe() const override {
++ return m_description;
++ }
++};
++
++ /**
++ * Creates a matcher that calls delegates `match` to the provided predicate.
++ *
++ * The user has to explicitly specify the argument type to the matcher
++ */
++ template<typename T, typename Pred>
++ PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
++ static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
++ static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
++ return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
++ }
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
++#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
++
++
++namespace Catch {
++ namespace Matchers {
++ // Matcher for checking that all elements in range matches a given matcher.
++ template <typename Matcher>
++ class AllMatchMatcher final : public MatcherGenericBase {
++ Matcher m_matcher;
++ public:
++ AllMatchMatcher(Matcher matcher):
++ m_matcher(CATCH_MOVE(matcher))
++ {}
++
++ std::string describe() const override {
++ return "all match " + m_matcher.describe();
++ }
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (!m_matcher.match(elem)) {
++ return false;
++ }
++ }
++ return true;
++ }
++ };
++
++ // Matcher for checking that no element in range matches a given matcher.
++ template <typename Matcher>
++ class NoneMatchMatcher final : public MatcherGenericBase {
++ Matcher m_matcher;
++ public:
++ NoneMatchMatcher(Matcher matcher):
++ m_matcher(CATCH_MOVE(matcher))
++ {}
++
++ std::string describe() const override {
++ return "none match " + m_matcher.describe();
++ }
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (m_matcher.match(elem)) {
++ return false;
++ }
++ }
++ return true;
++ }
++ };
++
++ // Matcher for checking that at least one element in range matches a given matcher.
++ template <typename Matcher>
++ class AnyMatchMatcher final : public MatcherGenericBase {
++ Matcher m_matcher;
++ public:
++ AnyMatchMatcher(Matcher matcher):
++ m_matcher(CATCH_MOVE(matcher))
++ {}
++
++ std::string describe() const override {
++ return "any match " + m_matcher.describe();
++ }
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (m_matcher.match(elem)) {
++ return true;
++ }
++ }
++ return false;
++ }
++ };
++
++ // Matcher for checking that all elements in range are true.
++ class AllTrueMatcher final : public MatcherGenericBase {
++ public:
++ std::string describe() const override;
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (!elem) {
++ return false;
++ }
++ }
++ return true;
++ }
++ };
++
++ // Matcher for checking that no element in range is true.
++ class NoneTrueMatcher final : public MatcherGenericBase {
++ public:
++ std::string describe() const override;
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (elem) {
++ return false;
++ }
++ }
++ return true;
++ }
++ };
++
++ // Matcher for checking that any element in range is true.
++ class AnyTrueMatcher final : public MatcherGenericBase {
++ public:
++ std::string describe() const override;
++
++ template <typename RangeLike>
++ bool match(RangeLike&& rng) const {
++ for (auto&& elem : rng) {
++ if (elem) {
++ return true;
++ }
++ }
++ return false;
++ }
++ };
++
++ // Creates a matcher that checks whether all elements in a range match a matcher
++ template <typename Matcher>
++ AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
++ return { CATCH_FORWARD(matcher) };
++ }
++
++ // Creates a matcher that checks whether no element in a range matches a matcher.
++ template <typename Matcher>
++ NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
++ return { CATCH_FORWARD(matcher) };
++ }
++
++ // Creates a matcher that checks whether any element in a range matches a matcher.
++ template <typename Matcher>
++ AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
++ return { CATCH_FORWARD(matcher) };
++ }
++
++ // Creates a matcher that checks whether all elements in a range are true
++ AllTrueMatcher AllTrue();
++
++ // Creates a matcher that checks whether no element in a range is true
++ NoneTrueMatcher NoneTrue();
++
++ // Creates a matcher that checks whether any element in a range is true
++ AnyTrueMatcher AnyTrue();
++ }
++}
++
++#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
++#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
++
++
++#include <algorithm>
++#include <utility>
++
++namespace Catch {
++ namespace Matchers {
++
++ /**
++ * Matcher for checking that an element contains the same
++ * elements in the same order
++ */
++ template <typename TargetRangeLike, typename Equality>
++ class RangeEqualsMatcher final : public MatcherGenericBase {
++ TargetRangeLike m_desired;
++ Equality m_predicate;
++
++ public:
++ template <typename TargetRangeLike2, typename Equality2>
++ RangeEqualsMatcher( TargetRangeLike2&& range,
++ Equality2&& predicate ):
++ m_desired( CATCH_FORWARD( range ) ),
++ m_predicate( CATCH_FORWARD( predicate ) ) {}
++
++ template <typename RangeLike>
++ bool match( RangeLike&& rng ) const {
++ auto rng_start = begin( rng );
++ const auto rng_end = end( rng );
++ auto target_start = begin( m_desired );
++ const auto target_end = end( m_desired );
++
++ while (rng_start != rng_end && target_start != target_end) {
++ if (!m_predicate(*rng_start, *target_start)) {
++ return false;
++ }
++ ++rng_start;
++ ++target_start;
++ }
++ return rng_start == rng_end && target_start == target_end;
++ }
++
++ std::string describe() const override {
++ return "elements are " + Catch::Detail::stringify( m_desired );
++ }
++ };
++
++ /**
++ * Matcher for checking that an element contains the same
++ * elements (but not necessarily in the same order)
++ */
++ template <typename TargetRangeLike, typename Equality>
++ class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
++ TargetRangeLike m_desired;
++ Equality m_predicate;
++
++ public:
++ template <typename TargetRangeLike2, typename Equality2>
++ UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
++ Equality2&& predicate ):
++ m_desired( CATCH_FORWARD( range ) ),
++ m_predicate( CATCH_FORWARD( predicate ) ) {}
++
++ template <typename RangeLike>
++ bool match( RangeLike&& rng ) const {
++ using std::begin;
++ using std::end;
++ return Catch::Detail::is_permutation( begin( m_desired ),
++ end( m_desired ),
++ begin( rng ),
++ end( rng ),
++ m_predicate );
++ }
++
++ std::string describe() const override {
++ return "unordered elements are " +
++ ::Catch::Detail::stringify( m_desired );
++ }
++ };
++
++ /**
++ * Creates a matcher that checks if all elements in a range are equal
++ * to all elements in another range.
++ *
++ * Uses `std::equal_to` to do the comparison
++ */
++ template <typename RangeLike>
++ std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
++ RangeEqualsMatcher<RangeLike, std::equal_to<>>>
++ RangeEquals( RangeLike&& range ) {
++ return { CATCH_FORWARD( range ), std::equal_to<>{} };
++ }
++
++ /**
++ * Creates a matcher that checks if all elements in a range are equal
++ * to all elements in another range.
++ *
++ * Uses to provided predicate `predicate` to do the comparisons
++ */
++ template <typename RangeLike, typename Equality>
++ RangeEqualsMatcher<RangeLike, Equality>
++ RangeEquals( RangeLike&& range, Equality&& predicate ) {
++ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
++ }
++
++ /**
++ * Creates a matcher that checks if all elements in a range are equal
++ * to all elements in another range, in some permutation
++ *
++ * Uses `std::equal_to` to do the comparison
++ */
++ template <typename RangeLike>
++ std::enable_if_t<
++ !Detail::is_matcher<RangeLike>::value,
++ UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
++ UnorderedRangeEquals( RangeLike&& range ) {
++ return { CATCH_FORWARD( range ), std::equal_to<>{} };
++ }
++
++ /**
++ * Creates a matcher that checks if all elements in a range are equal
++ * to all elements in another range, in some permutation.
++ *
++ * Uses to provided predicate `predicate` to do the comparisons
++ */
++ template <typename RangeLike, typename Equality>
++ UnorderedRangeEqualsMatcher<RangeLike, Equality>
++ UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
++ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
++ }
++ } // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
++#define CATCH_MATCHERS_STRING_HPP_INCLUDED
++
++
++#include <string>
++
++namespace Catch {
++namespace Matchers {
++
++ struct CasedString {
++ CasedString( std::string const& str, CaseSensitive caseSensitivity );
++ std::string adjustString( std::string const& str ) const;
++ StringRef caseSensitivitySuffix() const;
++
++ CaseSensitive m_caseSensitivity;
++ std::string m_str;
++ };
++
++ class StringMatcherBase : public MatcherBase<std::string> {
++ protected:
++ CasedString m_comparator;
++ StringRef m_operation;
++
++ public:
++ StringMatcherBase( StringRef operation,
++ CasedString const& comparator );
++ std::string describe() const override;
++ };
++
++ class StringEqualsMatcher final : public StringMatcherBase {
++ public:
++ StringEqualsMatcher( CasedString const& comparator );
++ bool match( std::string const& source ) const override;
++ };
++ class StringContainsMatcher final : public StringMatcherBase {
++ public:
++ StringContainsMatcher( CasedString const& comparator );
++ bool match( std::string const& source ) const override;
++ };
++ class StartsWithMatcher final : public StringMatcherBase {
++ public:
++ StartsWithMatcher( CasedString const& comparator );
++ bool match( std::string const& source ) const override;
++ };
++ class EndsWithMatcher final : public StringMatcherBase {
++ public:
++ EndsWithMatcher( CasedString const& comparator );
++ bool match( std::string const& source ) const override;
++ };
++
++ class RegexMatcher final : public MatcherBase<std::string> {
++ std::string m_regex;
++ CaseSensitive m_caseSensitivity;
++
++ public:
++ RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
++ bool match( std::string const& matchee ) const override;
++ std::string describe() const override;
++ };
++
++ //! Creates matcher that accepts strings that are exactly equal to `str`
++ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
++ //! Creates matcher that accepts strings that contain `str`
++ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
++ //! Creates matcher that accepts strings that _end_ with `str`
++ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
++ //! Creates matcher that accepts strings that _start_ with `str`
++ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
++ //! Creates matcher that accepts strings matching `regex`
++ RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
++
++
++#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
++#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
++
++
++#include <algorithm>
++
++namespace Catch {
++namespace Matchers {
++
++ template<typename T, typename Alloc>
++ class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
++ T const& m_comparator;
++
++ public:
++ VectorContainsElementMatcher(T const& comparator):
++ m_comparator(comparator)
++ {}
++
++ bool match(std::vector<T, Alloc> const& v) const override {
++ for (auto const& el : v) {
++ if (el == m_comparator) {
++ return true;
++ }
++ }
++ return false;
++ }
++
++ std::string describe() const override {
++ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
++ }
++ };
++
++ template<typename T, typename AllocComp, typename AllocMatch>
++ class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
++ std::vector<T, AllocComp> const& m_comparator;
++
++ public:
++ ContainsMatcher(std::vector<T, AllocComp> const& comparator):
++ m_comparator( comparator )
++ {}
++
++ bool match(std::vector<T, AllocMatch> const& v) const override {
++ // !TBD: see note in EqualsMatcher
++ if (m_comparator.size() > v.size())
++ return false;
++ for (auto const& comparator : m_comparator) {
++ auto present = false;
++ for (const auto& el : v) {
++ if (el == comparator) {
++ present = true;
++ break;
++ }
++ }
++ if (!present) {
++ return false;
++ }
++ }
++ return true;
++ }
++ std::string describe() const override {
++ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
++ }
++ };
++
++ template<typename T, typename AllocComp, typename AllocMatch>
++ class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
++ std::vector<T, AllocComp> const& m_comparator;
++
++ public:
++ EqualsMatcher(std::vector<T, AllocComp> const& comparator):
++ m_comparator( comparator )
++ {}
++
++ bool match(std::vector<T, AllocMatch> const& v) const override {
++ // !TBD: This currently works if all elements can be compared using !=
++ // - a more general approach would be via a compare template that defaults
++ // to using !=. but could be specialised for, e.g. std::vector<T> etc
++ // - then just call that directly
++ if ( m_comparator.size() != v.size() ) { return false; }
++ for ( std::size_t i = 0; i < v.size(); ++i ) {
++ if ( !( m_comparator[i] == v[i] ) ) { return false; }
++ }
++ return true;
++ }
++ std::string describe() const override {
++ return "Equals: " + ::Catch::Detail::stringify( m_comparator );
++ }
++ };
++
++ template<typename T, typename AllocComp, typename AllocMatch>
++ class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
++ std::vector<T, AllocComp> const& m_comparator;
++ mutable Catch::Approx approx = Catch::Approx::custom();
++
++ public:
++ ApproxMatcher(std::vector<T, AllocComp> const& comparator):
++ m_comparator( comparator )
++ {}
++
++ bool match(std::vector<T, AllocMatch> const& v) const override {
++ if (m_comparator.size() != v.size())
++ return false;
++ for (std::size_t i = 0; i < v.size(); ++i)
++ if (m_comparator[i] != approx(v[i]))
++ return false;
++ return true;
++ }
++ std::string describe() const override {
++ return "is approx: " + ::Catch::Detail::stringify( m_comparator );
++ }
++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ ApproxMatcher& epsilon( T const& newEpsilon ) {
++ approx.epsilon(static_cast<double>(newEpsilon));
++ return *this;
++ }
++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ ApproxMatcher& margin( T const& newMargin ) {
++ approx.margin(static_cast<double>(newMargin));
++ return *this;
++ }
++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
++ ApproxMatcher& scale( T const& newScale ) {
++ approx.scale(static_cast<double>(newScale));
++ return *this;
++ }
++ };
++
++ template<typename T, typename AllocComp, typename AllocMatch>
++ class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
++ std::vector<T, AllocComp> const& m_target;
++
++ public:
++ UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
++ m_target(target)
++ {}
++ bool match(std::vector<T, AllocMatch> const& vec) const override {
++ if (m_target.size() != vec.size()) {
++ return false;
++ }
++ return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
++ }
++
++ std::string describe() const override {
++ return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
++ }
++ };
++
++
++ // The following functions create the actual matcher objects.
++ // This allows the types to be inferred
++
++ //! Creates a matcher that matches vectors that contain all elements in `comparator`
++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
++ ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
++ return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
++ }
++
++ //! Creates a matcher that matches vectors that contain `comparator` as an element
++ template<typename T, typename Alloc = std::allocator<T>>
++ VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
++ return VectorContainsElementMatcher<T, Alloc>(comparator);
++ }
++
++ //! Creates a matcher that matches vectors that are exactly equal to `comparator`
++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
++ EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
++ return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
++ }
++
++ //! Creates a matcher that matches vectors that `comparator` as an element
++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
++ ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
++ return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
++ }
++
++ //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
++ UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
++ return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
++ }
++
++} // namespace Matchers
++} // namespace Catch
++
++#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
++
++#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
++
++
++/** \file
++ * This is a convenience header for Catch2's Reporter support. It includes
++ * **all** of Catch2 headers related to reporters, including all reporters.
++ *
++ * Generally the Catch2 users should use specific includes they need,
++ * but this header can be used instead for ease-of-experimentation, or
++ * just plain convenience, at the cost of (significantly) increased
++ * compilation times.
++ *
++ * When a new header (reporter) is added to either the `reporter` folder,
++ * or to the corresponding internal subfolder, it should be added here.
++ */
++
++#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
++#define CATCH_REPORTERS_ALL_HPP_INCLUDED
++
++
++
++#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
++#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
++
++
++
++#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
++#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
++
++
++
++#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
++#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
++
++
++#include <map>
++#include <string>
++
++namespace Catch {
++ class ColourImpl;
++
++ /**
++ * This is the base class for all reporters.
++ *
++ * If are writing a reporter, you must derive from this type, or one
++ * of the helper reporter bases that are derived from this type.
++ *
++ * ReporterBase centralizes handling of various common tasks in reporters,
++ * like storing the right stream for the reporters to write to, and
++ * providing the default implementation of the different listing events.
++ */
++ class ReporterBase : public IEventListener {
++ protected:
++ //! The stream wrapper as passed to us by outside code
++ Detail::unique_ptr<IStream> m_wrapped_stream;
++ //! Cached output stream from `m_wrapped_stream` to reduce
++ //! number of indirect calls needed to write output.
++ std::ostream& m_stream;
++ //! Colour implementation this reporter was configured for
++ Detail::unique_ptr<ColourImpl> m_colour;
++ //! The custom reporter options user passed down to the reporter
++ std::map<std::string, std::string> m_customOptions;
++
++ public:
++ ReporterBase( ReporterConfig&& config );
++ ~ReporterBase() override; // = default;
++
++ /**
++ * Provides a simple default listing of reporters.
++ *
++ * Should look roughly like the reporter listing in v2 and earlier
++ * versions of Catch2.
++ */
++ void listReporters(
++ std::vector<ReporterDescription> const& descriptions ) override;
++ /**
++ * Provides a simple default listing of listeners
++ *
++ * Looks similarly to listing of reporters, but with listener type
++ * instead of reporter name.
++ */
++ void listListeners(
++ std::vector<ListenerDescription> const& descriptions ) override;
++ /**
++ * Provides a simple default listing of tests.
++ *
++ * Should look roughly like the test listing in v2 and earlier versions
++ * of Catch2. Especially supports low-verbosity listing that mimics the
++ * old `--list-test-names-only` output.
++ */
++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
++ /**
++ * Provides a simple default listing of tags.
++ *
++ * Should look roughly like the tag listing in v2 and earlier versions
++ * of Catch2.
++ */
++ void listTags( std::vector<TagInfo> const& tags ) override;
++ };
++} // namespace Catch
++
++#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
++
++#include <vector>
++
++namespace Catch {
++
++ class StreamingReporterBase : public ReporterBase {
++ public:
++ // GCC5 compat: we cannot use inherited constructor, because it
++ // doesn't implement backport of P0136
++ StreamingReporterBase(ReporterConfig&& _config):
++ ReporterBase(CATCH_MOVE(_config))
++ {}
++ ~StreamingReporterBase() override;
++
++ void benchmarkPreparing( StringRef ) override {}
++ void benchmarkStarting( BenchmarkInfo const& ) override {}
++ void benchmarkEnded( BenchmarkStats<> const& ) override {}
++ void benchmarkFailed( StringRef ) override {}
++
++ void fatalErrorEncountered( StringRef /*error*/ ) override {}
++ void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
++ void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
++
++ void testRunStarting( TestRunInfo const& _testRunInfo ) override;
++
++ void testCaseStarting(TestCaseInfo const& _testInfo) override {
++ currentTestCaseInfo = &_testInfo;
++ }
++ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
++ void sectionStarting(SectionInfo const& _sectionInfo) override {
++ m_sectionStack.push_back(_sectionInfo);
++ }
++
++ void assertionStarting( AssertionInfo const& ) override {}
++ void assertionEnded( AssertionStats const& ) override {}
++
++ void sectionEnded(SectionStats const& /* _sectionStats */) override {
++ m_sectionStack.pop_back();
++ }
++ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
++ void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
++ currentTestCaseInfo = nullptr;
++ }
++ void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
++
++ void skipTest(TestCaseInfo const&) override {
++ // Don't do anything with this by default.
++ // It can optionally be overridden in the derived class.
++ }
++
++ protected:
++ TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
++ TestCaseInfo const* currentTestCaseInfo = nullptr;
++
++ //! Stack of all _active_ sections in the _current_ test case
++ std::vector<SectionInfo> m_sectionStack;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
++
++#include <string>
++
++namespace Catch {
++
++ class AutomakeReporter final : public StreamingReporterBase {
++ public:
++ // GCC5 compat: we cannot use inherited constructor, because it
++ // doesn't implement backport of P0136
++ AutomakeReporter(ReporterConfig&& _config):
++ StreamingReporterBase(CATCH_MOVE(_config))
++ {}
++ ~AutomakeReporter() override;
++
++ static std::string getDescription() {
++ using namespace std::string_literals;
++ return "Reports test results in the format of Automake .trs files"s;
++ }
++
++ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
++ void skipTest(TestCaseInfo const& testInfo) override;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
++#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
++
++
++
++
++namespace Catch {
++
++ class CompactReporter final : public StreamingReporterBase {
++ public:
++ using StreamingReporterBase::StreamingReporterBase;
++
++ ~CompactReporter() override;
++
++ static std::string getDescription();
++
++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
++
++ void testRunStarting( TestRunInfo const& _testInfo ) override;
++
++ void assertionEnded(AssertionStats const& _assertionStats) override;
++
++ void sectionEnded(SectionStats const& _sectionStats) override;
++
++ void testRunEnded(TestRunStats const& _testRunStats) override;
++
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
++#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
++
++
++namespace Catch {
++ // Fwd decls
++ class TablePrinter;
++
++ class ConsoleReporter final : public StreamingReporterBase {
++ Detail::unique_ptr<TablePrinter> m_tablePrinter;
++
++ public:
++ ConsoleReporter(ReporterConfig&& config);
++ ~ConsoleReporter() override;
++ static std::string getDescription();
++
++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
++ void reportInvalidTestSpec( StringRef arg ) override;
++
++ void assertionStarting(AssertionInfo const&) override;
++
++ void assertionEnded(AssertionStats const& _assertionStats) override;
++
++ void sectionStarting(SectionInfo const& _sectionInfo) override;
++ void sectionEnded(SectionStats const& _sectionStats) override;
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting(BenchmarkInfo const& info) override;
++ void benchmarkEnded(BenchmarkStats<> const& stats) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
++ void testRunEnded(TestRunStats const& _testRunStats) override;
++ void testRunStarting(TestRunInfo const& _testRunInfo) override;
++
++ private:
++ void lazyPrint();
++
++ void lazyPrintWithoutClosingBenchmarkTable();
++ void lazyPrintRunInfo();
++ void printTestCaseAndSectionHeader();
++
++ void printClosedHeader(std::string const& _name);
++ void printOpenHeader(std::string const& _name);
++
++ // if string has a : in first line will set indent to follow it on
++ // subsequent lines
++ void printHeaderString(std::string const& _string, std::size_t indent = 0);
++
++ void printTotalsDivider(Totals const& totals);
++
++ bool m_headerPrinted = false;
++ bool m_testRunInfoPrinted = false;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
++#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
++
++
++#include <string>
++#include <vector>
++
++namespace Catch {
++
++ namespace Detail {
++
++ //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
++ class AssertionOrBenchmarkResult {
++ // This should really be a variant, but this is much faster
++ // to write and the data layout here is already terrible
++ // enough that we do not have to care about the object size.
++ Optional<AssertionStats> m_assertion;
++ Optional<BenchmarkStats<>> m_benchmark;
++ public:
++ AssertionOrBenchmarkResult(AssertionStats const& assertion);
++ AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
++
++ bool isAssertion() const;
++ bool isBenchmark() const;
++
++ AssertionStats const& asAssertion() const;
++ BenchmarkStats<> const& asBenchmark() const;
++ };
++ }
++
++ /**
++ * Utility base for reporters that need to handle all results at once
++ *
++ * It stores tree of all test cases, sections and assertions, and after the
++ * test run is finished, calls into `testRunEndedCumulative` to pass the
++ * control to the deriving class.
++ *
++ * If you are deriving from this class and override any testing related
++ * member functions, you should first call into the base's implementation to
++ * avoid breaking the tree construction.
++ *
++ * Due to the way this base functions, it has to expand assertions up-front,
++ * even if they are later unused (e.g. because the deriving reporter does
++ * not report successful assertions, or because the deriving reporter does
++ * not use assertion expansion at all). Derived classes can use two
++ * customization points, `m_shouldStoreSuccesfulAssertions` and
++ * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
++ * performance. **Accessing the assertion expansions if it wasn't stored is
++ * UB.**
++ */
++ class CumulativeReporterBase : public ReporterBase {
++ public:
++ template<typename T, typename ChildNodeT>
++ struct Node {
++ explicit Node( T const& _value ) : value( _value ) {}
++
++ using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
++ T value;
++ ChildNodes children;
++ };
++ struct SectionNode {
++ explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
++
++ bool operator == (SectionNode const& other) const {
++ return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
++ }
++
++ bool hasAnyAssertions() const;
++
++ SectionStats stats;
++ std::vector<Detail::unique_ptr<SectionNode>> childSections;
++ std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
++ std::string stdOut;
++ std::string stdErr;
++ };
++
++
++ using TestCaseNode = Node<TestCaseStats, SectionNode>;
++ using TestRunNode = Node<TestRunStats, TestCaseNode>;
++
++ // GCC5 compat: we cannot use inherited constructor, because it
++ // doesn't implement backport of P0136
++ CumulativeReporterBase(ReporterConfig&& _config):
++ ReporterBase(CATCH_MOVE(_config))
++ {}
++ ~CumulativeReporterBase() override;
++
++ void benchmarkPreparing( StringRef ) override {}
++ void benchmarkStarting( BenchmarkInfo const& ) override {}
++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
++ void benchmarkFailed( StringRef ) override {}
++
++ void noMatchingTestCases( StringRef ) override {}
++ void reportInvalidTestSpec( StringRef ) override {}
++ void fatalErrorEncountered( StringRef /*error*/ ) override {}
++
++ void testRunStarting( TestRunInfo const& ) override {}
++
++ void testCaseStarting( TestCaseInfo const& ) override {}
++ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
++ void sectionStarting( SectionInfo const& sectionInfo ) override;
++
++ void assertionStarting( AssertionInfo const& ) override {}
++
++ void assertionEnded( AssertionStats const& assertionStats ) override;
++ void sectionEnded( SectionStats const& sectionStats ) override;
++ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
++ void testRunEnded( TestRunStats const& testRunStats ) override;
++ //! Customization point: called after last test finishes (testRunEnded has been handled)
++ virtual void testRunEndedCumulative() = 0;
++
++ void skipTest(TestCaseInfo const&) override {}
++
++ protected:
++ //! Should the cumulative base store the assertion expansion for successful assertions?
++ bool m_shouldStoreSuccesfulAssertions = true;
++ //! Should the cumulative base store the assertion expansion for failed assertions?
++ bool m_shouldStoreFailedAssertions = true;
++
++ // We need lazy construction here. We should probably refactor it
++ // later, after the events are redone.
++ //! The root node of the test run tree.
++ Detail::unique_ptr<TestRunNode> m_testRun;
++
++ private:
++ // Note: We rely on pointer identity being stable, which is why
++ // we store pointers to the nodes rather than the values.
++ std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
++ // Root section of the _current_ test case
++ Detail::unique_ptr<SectionNode> m_rootSection;
++ // Deepest section of the _current_ test case
++ SectionNode* m_deepestSection = nullptr;
++ // Stack of _active_ sections in the _current_ test case
++ std::vector<SectionNode*> m_sectionStack;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
++#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
++
++
++namespace Catch {
++
++ /**
++ * Base class to simplify implementing listeners.
++ *
++ * Provides empty default implementation for all IEventListener member
++ * functions, so that a listener implementation can pick which
++ * member functions it actually cares about.
++ */
++ class EventListenerBase : public IEventListener {
++ public:
++ using IEventListener::IEventListener;
++
++ void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
++ void fatalErrorEncountered( StringRef error ) override;
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
++ void assertionEnded( AssertionStats const& assertionStats ) override;
++
++ void listReporters(
++ std::vector<ReporterDescription> const& descriptions ) override;
++ void listListeners(
++ std::vector<ListenerDescription> const& descriptions ) override;
++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
++ void listTags( std::vector<TagInfo> const& tagInfos ) override;
++
++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
++ void testCaseStarting( TestCaseInfo const& testInfo ) override;
++ void testCasePartialStarting( TestCaseInfo const& testInfo,
++ uint64_t partNumber ) override;
++ void sectionStarting( SectionInfo const& sectionInfo ) override;
++ void sectionEnded( SectionStats const& sectionStats ) override;
++ void testCasePartialEnded( TestCaseStats const& testCaseStats,
++ uint64_t partNumber ) override;
++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
++ void testRunEnded( TestRunStats const& testRunStats ) override;
++ void skipTest( TestCaseInfo const& testInfo ) override;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
++#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
++
++#include <iosfwd>
++#include <string>
++#include <vector>
++
++
++namespace Catch {
++
++ class IConfig;
++ class TestCaseHandle;
++ class ColourImpl;
++
++ // Returns double formatted as %.3f (format expected on output)
++ std::string getFormattedDuration( double duration );
++
++ //! Should the reporter show duration of test given current configuration?
++ bool shouldShowDuration( IConfig const& config, double duration );
++
++ std::string serializeFilters( std::vector<std::string> const& filters );
++
++ struct lineOfChars {
++ char c;
++ constexpr lineOfChars( char c_ ): c( c_ ) {}
++
++ friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
++ };
++
++ /**
++ * Lists reporter descriptions to the provided stream in user-friendly
++ * format
++ *
++ * Used as the default listing implementation by the first party reporter
++ * bases. The output should be backwards compatible with the output of
++ * Catch2 v2 binaries.
++ */
++ void
++ defaultListReporters( std::ostream& out,
++ std::vector<ReporterDescription> const& descriptions,
++ Verbosity verbosity );
++
++ /**
++ * Lists listeners descriptions to the provided stream in user-friendly
++ * format
++ */
++ void defaultListListeners( std::ostream& out,
++ std::vector<ListenerDescription> const& descriptions );
++
++ /**
++ * Lists tag information to the provided stream in user-friendly format
++ *
++ * Used as the default listing implementation by the first party reporter
++ * bases. The output should be backwards compatible with the output of
++ * Catch2 v2 binaries.
++ */
++ void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
++
++ /**
++ * Lists test case information to the provided stream in user-friendly
++ * format
++ *
++ * Used as the default listing implementation by the first party reporter
++ * bases. The output is backwards compatible with the output of Catch2
++ * v2 binaries, and also supports the format specific to the old
++ * `--list-test-names-only` option, for people who used it in integrations.
++ */
++ void defaultListTests( std::ostream& out,
++ ColourImpl* streamColour,
++ std::vector<TestCaseHandle> const& tests,
++ bool isFiltered,
++ Verbosity verbosity );
++
++ /**
++ * Prints test run totals to the provided stream in user-friendly format
++ *
++ * Used by the console and compact reporters.
++ */
++ void printTestRunTotals( std::ostream& stream,
++ ColourImpl& streamColour,
++ Totals const& totals );
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
++
++
++
++#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
++#define CATCH_REPORTER_JSON_HPP_INCLUDED
++
++
++#include <stack>
++
++namespace Catch {
++ class JsonReporter : public StreamingReporterBase {
++ public:
++ JsonReporter( ReporterConfig&& config );
++
++ ~JsonReporter() override;
++
++ static std::string getDescription();
++
++ public: // StreamingReporterBase
++ void testRunStarting( TestRunInfo const& runInfo ) override;
++ void testRunEnded( TestRunStats const& runStats ) override;
++
++ void testCaseStarting( TestCaseInfo const& tcInfo ) override;
++ void testCaseEnded( TestCaseStats const& tcStats ) override;
++
++ void testCasePartialStarting( TestCaseInfo const& tcInfo,
++ uint64_t index ) override;
++ void testCasePartialEnded( TestCaseStats const& tcStats,
++ uint64_t index ) override;
++
++ void sectionStarting( SectionInfo const& sectionInfo ) override;
++ void sectionEnded( SectionStats const& sectionStats ) override;
++
++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
++ void assertionEnded( AssertionStats const& assertionStats ) override;
++
++ //void testRunEndedCumulative() override;
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting( BenchmarkInfo const& ) override;
++ void benchmarkEnded( BenchmarkStats<> const& ) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void listReporters(
++ std::vector<ReporterDescription> const& descriptions ) override;
++ void listListeners(
++ std::vector<ListenerDescription> const& descriptions ) override;
++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
++ void listTags( std::vector<TagInfo> const& tags ) override;
++
++ private:
++ Timer m_testCaseTimer;
++ enum class Writer {
++ Object,
++ Array
++ };
++
++ JsonArrayWriter& startArray();
++ JsonArrayWriter& startArray( StringRef key );
++
++ JsonObjectWriter& startObject();
++ JsonObjectWriter& startObject( StringRef key );
++
++ void endObject();
++ void endArray();
++
++ bool isInside( Writer writer );
++
++ void startListing();
++ void endListing();
++
++ // Invariant:
++ // When m_writers is not empty and its top element is
++ // - Writer::Object, then m_objectWriters is not be empty
++ // - Writer::Array, then m_arrayWriters shall not be empty
++ std::stack<JsonObjectWriter> m_objectWriters{};
++ std::stack<JsonArrayWriter> m_arrayWriters{};
++ std::stack<Writer> m_writers{};
++
++ bool m_startedListing = false;
++
++ // std::size_t m_sectionDepth = 0;
++ // std::size_t m_sectionStarted = 0;
++ };
++} // namespace Catch
++
++#endif // CATCH_REPORTER_JSON_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
++#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
++
++
++
++namespace Catch {
++
++ class JunitReporter final : public CumulativeReporterBase {
++ public:
++ JunitReporter(ReporterConfig&& _config);
++
++ static std::string getDescription();
++
++ void testRunStarting(TestRunInfo const& runInfo) override;
++
++ void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
++ void assertionEnded(AssertionStats const& assertionStats) override;
++
++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
++
++ void testRunEndedCumulative() override;
++
++ private:
++ void writeRun(TestRunNode const& testRunNode, double suiteTime);
++
++ void writeTestCase(TestCaseNode const& testCaseNode);
++
++ void writeSection( std::string const& className,
++ std::string const& rootName,
++ SectionNode const& sectionNode,
++ bool testOkToFail );
++
++ void writeAssertions(SectionNode const& sectionNode);
++ void writeAssertion(AssertionStats const& stats);
++
++ XmlWriter xml;
++ Timer suiteTimer;
++ std::string stdOutForSuite;
++ std::string stdErrForSuite;
++ unsigned int unexpectedExceptions = 0;
++ bool m_okToFail = false;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
++#define CATCH_REPORTER_MULTI_HPP_INCLUDED
++
++
++namespace Catch {
++
++ class MultiReporter final : public IEventListener {
++ /*
++ * Stores all added reporters and listeners
++ *
++ * All Listeners are stored before all reporters, and individual
++ * listeners/reporters are stored in order of insertion.
++ */
++ std::vector<IEventListenerPtr> m_reporterLikes;
++ bool m_haveNoncapturingReporters = false;
++
++ // Keep track of how many listeners we have already inserted,
++ // so that we can insert them into the main vector at the right place
++ size_t m_insertedListeners = 0;
++
++ void updatePreferences(IEventListener const& reporterish);
++
++ public:
++ using IEventListener::IEventListener;
++
++ void addListener( IEventListenerPtr&& listener );
++ void addReporter( IEventListenerPtr&& reporter );
++
++ public: // IEventListener
++
++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
++ void fatalErrorEncountered( StringRef error ) override;
++ void reportInvalidTestSpec( StringRef arg ) override;
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
++ void testCaseStarting( TestCaseInfo const& testInfo ) override;
++ void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
++ void sectionStarting( SectionInfo const& sectionInfo ) override;
++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
++
++ void assertionEnded( AssertionStats const& assertionStats ) override;
++ void sectionEnded( SectionStats const& sectionStats ) override;
++ void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
++ void testRunEnded( TestRunStats const& testRunStats ) override;
++
++ void skipTest( TestCaseInfo const& testInfo ) override;
++
++ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
++ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
++ void listTests(std::vector<TestCaseHandle> const& tests) override;
++ void listTags(std::vector<TagInfo> const& tags) override;
++
++
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
++#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
++
++
++#include <type_traits>
++
++namespace Catch {
++
++ namespace Detail {
++
++ template <typename T, typename = void>
++ struct has_description : std::false_type {};
++
++ template <typename T>
++ struct has_description<
++ T,
++ void_t<decltype( T::getDescription() )>>
++ : std::true_type {};
++
++ //! Indirection for reporter registration, so that the error handling is
++ //! independent on the reporter's concrete type
++ void registerReporterImpl( std::string const& name,
++ IReporterFactoryPtr reporterPtr );
++ //! Actually registers the factory, independent on listener's concrete type
++ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
++ } // namespace Detail
++
++ class IEventListener;
++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
++
++ template <typename T>
++ class ReporterFactory : public IReporterFactory {
++
++ IEventListenerPtr create( ReporterConfig&& config ) const override {
++ return Detail::make_unique<T>( CATCH_MOVE(config) );
++ }
++
++ std::string getDescription() const override {
++ return T::getDescription();
++ }
++ };
++
++
++ template<typename T>
++ class ReporterRegistrar {
++ public:
++ explicit ReporterRegistrar( std::string const& name ) {
++ registerReporterImpl( name,
++ Detail::make_unique<ReporterFactory<T>>() );
++ }
++ };
++
++ template<typename T>
++ class ListenerRegistrar {
++
++ class TypedListenerFactory : public EventListenerFactory {
++ StringRef m_listenerName;
++
++ std::string getDescriptionImpl( std::true_type ) const {
++ return T::getDescription();
++ }
++
++ std::string getDescriptionImpl( std::false_type ) const {
++ return "(No description provided)";
++ }
++
++ public:
++ TypedListenerFactory( StringRef listenerName ):
++ m_listenerName( listenerName ) {}
++
++ IEventListenerPtr create( IConfig const* config ) const override {
++ return Detail::make_unique<T>( config );
++ }
++
++ StringRef getName() const override {
++ return m_listenerName;
++ }
++
++ std::string getDescription() const override {
++ return getDescriptionImpl( Detail::has_description<T>{} );
++ }
++ };
++
++ public:
++ ListenerRegistrar(StringRef listenerName) {
++ registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
++ }
++ };
++}
++
++#if !defined(CATCH_CONFIG_DISABLE)
++
++# define CATCH_REGISTER_REPORTER( name, reporterType ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ namespace { \
++ Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
++ catch_internal_RegistrarFor )( name ); \
++ } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++# define CATCH_REGISTER_LISTENER( listenerType ) \
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
++ namespace { \
++ Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
++ catch_internal_RegistrarFor )( #listenerType##_catch_sr ); \
++ } \
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++
++#else // CATCH_CONFIG_DISABLE
++
++#define CATCH_REGISTER_REPORTER(name, reporterType)
++#define CATCH_REGISTER_LISTENER(listenerType)
++
++#endif // CATCH_CONFIG_DISABLE
++
++#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
++#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
++
++
++
++namespace Catch {
++
++ class SonarQubeReporter final : public CumulativeReporterBase {
++ public:
++ SonarQubeReporter(ReporterConfig&& config)
++ : CumulativeReporterBase(CATCH_MOVE(config))
++ , xml(m_stream) {
++ m_preferences.shouldRedirectStdOut = true;
++ m_preferences.shouldReportAllAssertions = true;
++ m_shouldStoreSuccesfulAssertions = false;
++ }
++
++ static std::string getDescription() {
++ using namespace std::string_literals;
++ return "Reports test results in the Generic Test Data SonarQube XML format"s;
++ }
++
++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
++
++ void testRunEndedCumulative() override {
++ writeRun( *m_testRun );
++ xml.endElement();
++ }
++
++ void writeRun( TestRunNode const& runNode );
++
++ void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
++
++ void writeTestCase(TestCaseNode const& testCaseNode);
++
++ void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
++
++ void writeAssertions(SectionNode const& sectionNode, bool okToFail);
++
++ void writeAssertion(AssertionStats const& stats, bool okToFail);
++
++ private:
++ XmlWriter xml;
++ };
++
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
++#define CATCH_REPORTER_TAP_HPP_INCLUDED
++
++
++namespace Catch {
++
++ class TAPReporter final : public StreamingReporterBase {
++ public:
++ TAPReporter( ReporterConfig&& config ):
++ StreamingReporterBase( CATCH_MOVE(config) ) {
++ m_preferences.shouldReportAllAssertions = true;
++ }
++
++ static std::string getDescription() {
++ using namespace std::string_literals;
++ return "Reports test results in TAP format, suitable for test harnesses"s;
++ }
++
++ void testRunStarting( TestRunInfo const& testInfo ) override;
++
++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
++
++ void assertionEnded(AssertionStats const& _assertionStats) override;
++
++ void testRunEnded(TestRunStats const& _testRunStats) override;
++
++ private:
++ std::size_t counter = 0;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
++#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
++
++
++#include <cstring>
++
++#ifdef __clang__
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wpadded"
++#endif
++
++namespace Catch {
++
++ class TeamCityReporter final : public StreamingReporterBase {
++ public:
++ TeamCityReporter( ReporterConfig&& _config )
++ : StreamingReporterBase( CATCH_MOVE(_config) )
++ {
++ m_preferences.shouldRedirectStdOut = true;
++ }
++
++ ~TeamCityReporter() override;
++
++ static std::string getDescription() {
++ using namespace std::string_literals;
++ return "Reports test results as TeamCity service messages"s;
++ }
++
++ void testRunStarting( TestRunInfo const& runInfo ) override;
++ void testRunEnded( TestRunStats const& runStats ) override;
++
++
++ void assertionEnded(AssertionStats const& assertionStats) override;
++
++ void sectionStarting(SectionInfo const& sectionInfo) override {
++ m_headerPrintedForThisSection = false;
++ StreamingReporterBase::sectionStarting( sectionInfo );
++ }
++
++ void testCaseStarting(TestCaseInfo const& testInfo) override;
++
++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
++
++ private:
++ void printSectionHeader(std::ostream& os);
++
++ bool m_headerPrintedForThisSection = false;
++ Timer m_testTimer;
++ };
++
++} // end namespace Catch
++
++#ifdef __clang__
++# pragma clang diagnostic pop
++#endif
++
++#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
++
++
++#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
++#define CATCH_REPORTER_XML_HPP_INCLUDED
++
++
++
++
++namespace Catch {
++ class XmlReporter : public StreamingReporterBase {
++ public:
++ XmlReporter(ReporterConfig&& _config);
++
++ ~XmlReporter() override;
++
++ static std::string getDescription();
++
++ virtual std::string getStylesheetRef() const;
++
++ void writeSourceInfo(SourceLineInfo const& sourceInfo);
++
++ public: // StreamingReporterBase
++
++ void testRunStarting(TestRunInfo const& testInfo) override;
++
++ void testCaseStarting(TestCaseInfo const& testInfo) override;
++
++ void sectionStarting(SectionInfo const& sectionInfo) override;
++
++ void assertionStarting(AssertionInfo const&) override;
++
++ void assertionEnded(AssertionStats const& assertionStats) override;
++
++ void sectionEnded(SectionStats const& sectionStats) override;
++
++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
++
++ void testRunEnded(TestRunStats const& testRunStats) override;
++
++ void benchmarkPreparing( StringRef name ) override;
++ void benchmarkStarting(BenchmarkInfo const&) override;
++ void benchmarkEnded(BenchmarkStats<> const&) override;
++ void benchmarkFailed( StringRef error ) override;
++
++ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
++ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
++ void listTests(std::vector<TestCaseHandle> const& tests) override;
++ void listTags(std::vector<TagInfo> const& tags) override;
++
++ private:
++ Timer m_testCaseTimer;
++ XmlWriter m_xml;
++ int m_sectionDepth = 0;
++ };
++
++} // end namespace Catch
++
++#endif // CATCH_REPORTER_XML_HPP_INCLUDED
++
++#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
++
++#endif // CATCH_ALL_HPP_INCLUDED
++#endif // CATCH_AMALGAMATED_HPP_INCLUDED
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/main.cpp
+@@ -0,0 +1,11638 @@
++
++// Copyright Catch2 Authors
++// Distributed under the Boost Software License, Version 1.0.
++// (See accompanying file LICENSE.txt or copy at
++// https://www.boost.org/LICENSE_1_0.txt)
++
++// SPDX-License-Identifier: BSL-1.0
++
++// Catch v3.6.0
++// Generated: 2024-05-05 20:53:27.562886
++// ----------------------------------------------------------
++// This file is an amalgamation of multiple different files.
++// You probably shouldn't edit it directly.
++// ----------------------------------------------------------
++
++#include "catch.hpp"
++
++
++#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
++#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
++
++
++#if defined(CATCH_PLATFORM_WINDOWS)
++
++// We might end up with the define made globally through the compiler,
++// and we don't want to trigger warnings for this
++#if !defined(NOMINMAX)
++# define NOMINMAX
++#endif
++#if !defined(WIN32_LEAN_AND_MEAN)
++# define WIN32_LEAN_AND_MEAN
++#endif
++
++#include <windows.h>
++
++#endif // defined(CATCH_PLATFORM_WINDOWS)
++
++#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
++
++
++
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ ChronometerConcept::~ChronometerConcept() = default;
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++
++// Adapted from donated nonius code.
++
++
++#include <vector>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
++ if (!cfg.benchmarkNoAnalysis()) {
++ std::vector<double> samples;
++ samples.reserve(static_cast<size_t>(last - first));
++ for (auto current = first; current != last; ++current) {
++ samples.push_back( current->count() );
++ }
++
++ auto analysis = Catch::Benchmark::Detail::analyse_samples(
++ cfg.benchmarkConfidenceInterval(),
++ cfg.benchmarkResamples(),
++ samples.data(),
++ samples.data() + samples.size() );
++ auto outliers = Catch::Benchmark::Detail::classify_outliers(
++ samples.data(), samples.data() + samples.size() );
++
++ auto wrap_estimate = [](Estimate<double> e) {
++ return Estimate<FDuration> {
++ FDuration(e.point),
++ FDuration(e.lower_bound),
++ FDuration(e.upper_bound),
++ e.confidence_interval,
++ };
++ };
++ std::vector<FDuration> samples2;
++ samples2.reserve(samples.size());
++ for (auto s : samples) {
++ samples2.push_back( FDuration( s ) );
++ }
++
++ return {
++ CATCH_MOVE(samples2),
++ wrap_estimate(analysis.mean),
++ wrap_estimate(analysis.standard_deviation),
++ outliers,
++ analysis.outlier_variance,
++ };
++ } else {
++ std::vector<FDuration> samples;
++ samples.reserve(static_cast<size_t>(last - first));
++
++ FDuration mean = FDuration(0);
++ int i = 0;
++ for (auto it = first; it < last; ++it, ++i) {
++ samples.push_back(*it);
++ mean += *it;
++ }
++ mean /= i;
++
++ return SampleAnalysis{
++ CATCH_MOVE(samples),
++ Estimate<FDuration>{ mean, mean, mean, 0.0 },
++ Estimate<FDuration>{ FDuration( 0 ),
++ FDuration( 0 ),
++ FDuration( 0 ),
++ 0.0 },
++ OutlierClassification{},
++ 0.0
++ };
++ }
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++
++
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ BenchmarkFunction::callable::~callable() = default;
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++
++
++
++#include <exception>
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ struct optimized_away_error : std::exception {
++ const char* what() const noexcept override;
++ };
++
++ const char* optimized_away_error::what() const noexcept {
++ return "could not measure benchmark, maybe it was optimized away";
++ }
++
++ void throw_optimized_away_error() {
++ Catch::throw_exception(optimized_away_error{});
++ }
++
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++
++// Adapted from donated nonius code.
++
++
++
++#include <algorithm>
++#include <cassert>
++#include <cmath>
++#include <cstddef>
++#include <numeric>
++#include <random>
++
++
++#if defined(CATCH_CONFIG_USE_ASYNC)
++#include <future>
++#endif
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++ namespace {
++
++ template <typename URng, typename Estimator>
++ static sample
++ resample( URng& rng,
++ unsigned int resamples,
++ double const* first,
++ double const* last,
++ Estimator& estimator ) {
++ auto n = static_cast<size_t>( last - first );
++ Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
++
++ sample out;
++ out.reserve( resamples );
++ std::vector<double> resampled;
++ resampled.reserve( n );
++ for ( size_t i = 0; i < resamples; ++i ) {
++ resampled.clear();
++ for ( size_t s = 0; s < n; ++s ) {
++ resampled.push_back( first[dist( rng )] );
++ }
++ const auto estimate =
++ estimator( resampled.data(), resampled.data() + resampled.size() );
++ out.push_back( estimate );
++ }
++ std::sort( out.begin(), out.end() );
++ return out;
++ }
++
++ static double outlier_variance( Estimate<double> mean,
++ Estimate<double> stddev,
++ int n ) {
++ double sb = stddev.point;
++ double mn = mean.point / n;
++ double mg_min = mn / 2.;
++ double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
++ double sg2 = sg * sg;
++ double sb2 = sb * sb;
++
++ auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
++ double k = mn - x;
++ double d = k * k;
++ double nd = n * d;
++ double k0 = -n * nd;
++ double k1 = sb2 - n * sg2 + nd;
++ double det = k1 * k1 - 4 * sg2 * k0;
++ return static_cast<int>( -2. * k0 /
++ ( k1 + std::sqrt( det ) ) );
++ };
++
++ auto var_out = [n, sb2, sg2]( double c ) {
++ double nc = n - c;
++ return ( nc / n ) * ( sb2 - nc * sg2 );
++ };
++
++ return (std::min)( var_out( 1 ),
++ var_out(
++ (std::min)( c_max( 0. ),
++ c_max( mg_min ) ) ) ) /
++ sb2;
++ }
++
++ static double erf_inv( double x ) {
++ // Code accompanying the article "Approximating the erfinv
++ // function" in GPU Computing Gems, Volume 2
++ double w, p;
++
++ w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
++
++ if ( w < 6.250000 ) {
++ w = w - 3.125000;
++ p = -3.6444120640178196996e-21;
++ p = -1.685059138182016589e-19 + p * w;
++ p = 1.2858480715256400167e-18 + p * w;
++ p = 1.115787767802518096e-17 + p * w;
++ p = -1.333171662854620906e-16 + p * w;
++ p = 2.0972767875968561637e-17 + p * w;
++ p = 6.6376381343583238325e-15 + p * w;
++ p = -4.0545662729752068639e-14 + p * w;
++ p = -8.1519341976054721522e-14 + p * w;
++ p = 2.6335093153082322977e-12 + p * w;
++ p = -1.2975133253453532498e-11 + p * w;
++ p = -5.4154120542946279317e-11 + p * w;
++ p = 1.051212273321532285e-09 + p * w;
++ p = -4.1126339803469836976e-09 + p * w;
++ p = -2.9070369957882005086e-08 + p * w;
++ p = 4.2347877827932403518e-07 + p * w;
++ p = -1.3654692000834678645e-06 + p * w;
++ p = -1.3882523362786468719e-05 + p * w;
++ p = 0.0001867342080340571352 + p * w;
++ p = -0.00074070253416626697512 + p * w;
++ p = -0.0060336708714301490533 + p * w;
++ p = 0.24015818242558961693 + p * w;
++ p = 1.6536545626831027356 + p * w;
++ } else if ( w < 16.000000 ) {
++ w = sqrt( w ) - 3.250000;
++ p = 2.2137376921775787049e-09;
++ p = 9.0756561938885390979e-08 + p * w;
++ p = -2.7517406297064545428e-07 + p * w;
++ p = 1.8239629214389227755e-08 + p * w;
++ p = 1.5027403968909827627e-06 + p * w;
++ p = -4.013867526981545969e-06 + p * w;
++ p = 2.9234449089955446044e-06 + p * w;
++ p = 1.2475304481671778723e-05 + p * w;
++ p = -4.7318229009055733981e-05 + p * w;
++ p = 6.8284851459573175448e-05 + p * w;
++ p = 2.4031110387097893999e-05 + p * w;
++ p = -0.0003550375203628474796 + p * w;
++ p = 0.00095328937973738049703 + p * w;
++ p = -0.0016882755560235047313 + p * w;
++ p = 0.0024914420961078508066 + p * w;
++ p = -0.0037512085075692412107 + p * w;
++ p = 0.005370914553590063617 + p * w;
++ p = 1.0052589676941592334 + p * w;
++ p = 3.0838856104922207635 + p * w;
++ } else {
++ w = sqrt( w ) - 5.000000;
++ p = -2.7109920616438573243e-11;
++ p = -2.5556418169965252055e-10 + p * w;
++ p = 1.5076572693500548083e-09 + p * w;
++ p = -3.7894654401267369937e-09 + p * w;
++ p = 7.6157012080783393804e-09 + p * w;
++ p = -1.4960026627149240478e-08 + p * w;
++ p = 2.9147953450901080826e-08 + p * w;
++ p = -6.7711997758452339498e-08 + p * w;
++ p = 2.2900482228026654717e-07 + p * w;
++ p = -9.9298272942317002539e-07 + p * w;
++ p = 4.5260625972231537039e-06 + p * w;
++ p = -1.9681778105531670567e-05 + p * w;
++ p = 7.5995277030017761139e-05 + p * w;
++ p = -0.00021503011930044477347 + p * w;
++ p = -0.00013871931833623122026 + p * w;
++ p = 1.0103004648645343977 + p * w;
++ p = 4.8499064014085844221 + p * w;
++ }
++ return p * x;
++ }
++
++ static double
++ standard_deviation( double const* first, double const* last ) {
++ auto m = Catch::Benchmark::Detail::mean( first, last );
++ double variance =
++ std::accumulate( first,
++ last,
++ 0.,
++ [m]( double a, double b ) {
++ double diff = b - m;
++ return a + diff * diff;
++ } ) /
++ ( last - first );
++ return std::sqrt( variance );
++ }
++
++ static sample jackknife( double ( *estimator )( double const*,
++ double const* ),
++ double* first,
++ double* last ) {
++ const auto second = first + 1;
++ sample results;
++ results.reserve( static_cast<size_t>( last - first ) );
++
++ for ( auto it = first; it != last; ++it ) {
++ std::iter_swap( it, first );
++ results.push_back( estimator( second, last ) );
++ }
++
++ return results;
++ }
++
++
++ } // namespace
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++namespace Catch {
++ namespace Benchmark {
++ namespace Detail {
++
++ double weighted_average_quantile( int k,
++ int q,
++ double* first,
++ double* last ) {
++ auto count = last - first;
++ double idx = (count - 1) * k / static_cast<double>(q);
++ int j = static_cast<int>(idx);
++ double g = idx - j;
++ std::nth_element(first, first + j, last);
++ auto xj = first[j];
++ if ( Catch::Detail::directCompare( g, 0 ) ) {
++ return xj;
++ }
++
++ auto xj1 = *std::min_element(first + (j + 1), last);
++ return xj + g * (xj1 - xj);
++ }
++
++ OutlierClassification
++ classify_outliers( double const* first, double const* last ) {
++ std::vector<double> copy( first, last );
++
++ auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
++ auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
++ auto iqr = q3 - q1;
++ auto los = q1 - ( iqr * 3. );
++ auto lom = q1 - ( iqr * 1.5 );
++ auto him = q3 + ( iqr * 1.5 );
++ auto his = q3 + ( iqr * 3. );
++
++ OutlierClassification o;
++ for ( ; first != last; ++first ) {
++ const double t = *first;
++ if ( t < los ) {
++ ++o.low_severe;
++ } else if ( t < lom ) {
++ ++o.low_mild;
++ } else if ( t > his ) {
++ ++o.high_severe;
++ } else if ( t > him ) {
++ ++o.high_mild;
++ }
++ ++o.samples_seen;
++ }
++ return o;
++ }
++
++ double mean( double const* first, double const* last ) {
++ auto count = last - first;
++ double sum = 0.;
++ while (first != last) {
++ sum += *first;
++ ++first;
++ }
++ return sum / static_cast<double>(count);
++ }
++
++ double normal_cdf( double x ) {
++ return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
++ }
++
++ double erfc_inv(double x) {
++ return erf_inv(1.0 - x);
++ }
++
++ double normal_quantile(double p) {
++ static const double ROOT_TWO = std::sqrt(2.0);
++
++ double result = 0.0;
++ assert(p >= 0 && p <= 1);
++ if (p < 0 || p > 1) {
++ return result;
++ }
++
++ result = -erfc_inv(2.0 * p);
++ // result *= normal distribution standard deviation (1.0) * sqrt(2)
++ result *= /*sd * */ ROOT_TWO;
++ // result += normal disttribution mean (0)
++ return result;
++ }
++
++ Estimate<double>
++ bootstrap( double confidence_level,
++ double* first,
++ double* last,
++ sample const& resample,
++ double ( *estimator )( double const*, double const* ) ) {
++ auto n_samples = last - first;
++
++ double point = estimator( first, last );
++ // Degenerate case with a single sample
++ if ( n_samples == 1 )
++ return { point, point, point, confidence_level };
++
++ sample jack = jackknife( estimator, first, last );
++ double jack_mean =
++ mean( jack.data(), jack.data() + jack.size() );
++ double sum_squares = 0, sum_cubes = 0;
++ for ( double x : jack ) {
++ auto difference = jack_mean - x;
++ auto square = difference * difference;
++ auto cube = square * difference;
++ sum_squares += square;
++ sum_cubes += cube;
++ }
++
++ double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
++ long n = static_cast<long>( resample.size() );
++ double prob_n =
++ std::count_if( resample.begin(),
++ resample.end(),
++ [point]( double x ) { return x < point; } ) /
++ static_cast<double>( n );
++ // degenerate case with uniform samples
++ if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
++ return { point, point, point, confidence_level };
++ }
++
++ double bias = normal_quantile( prob_n );
++ double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
++
++ auto cumn = [n]( double x ) -> long {
++ return std::lround( normal_cdf( x ) *
++ static_cast<double>( n ) );
++ };
++ auto a = [bias, accel]( double b ) {
++ return bias + b / ( 1. - accel * b );
++ };
++ double b1 = bias + z1;
++ double b2 = bias - z1;
++ double a1 = a( b1 );
++ double a2 = a( b2 );
++ auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
++ auto hi =
++ static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
++
++ return { point, resample[lo], resample[hi], confidence_level };
++ }
++
++ bootstrap_analysis analyse_samples(double confidence_level,
++ unsigned int n_resamples,
++ double* first,
++ double* last) {
++ auto mean = &Detail::mean;
++ auto stddev = &standard_deviation;
++
++#if defined(CATCH_CONFIG_USE_ASYNC)
++ auto Estimate = [=](double(*f)(double const*, double const*)) {
++ std::random_device rd;
++ auto seed = rd();
++ return std::async(std::launch::async, [=] {
++ SimplePcg32 rng( seed );
++ auto resampled = resample(rng, n_resamples, first, last, f);
++ return bootstrap(confidence_level, first, last, resampled, f);
++ });
++ };
++
++ auto mean_future = Estimate(mean);
++ auto stddev_future = Estimate(stddev);
++
++ auto mean_estimate = mean_future.get();
++ auto stddev_estimate = stddev_future.get();
++#else
++ auto Estimate = [=](double(*f)(double const* , double const*)) {
++ std::random_device rd;
++ auto seed = rd();
++ SimplePcg32 rng( seed );
++ auto resampled = resample(rng, n_resamples, first, last, f);
++ return bootstrap(confidence_level, first, last, resampled, f);
++ };
++
++ auto mean_estimate = Estimate(mean);
++ auto stddev_estimate = Estimate(stddev);
++#endif // CATCH_USE_ASYNC
++
++ auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
++ double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
++
++ return { mean_estimate, stddev_estimate, outlier_variance };
++ }
++ } // namespace Detail
++ } // namespace Benchmark
++} // namespace Catch
++
++
++
++#include <cmath>
++#include <limits>
++
++namespace {
++
++// Performs equivalent check of std::fabs(lhs - rhs) <= margin
++// But without the subtraction to allow for INFINITY in comparison
++bool marginComparison(double lhs, double rhs, double margin) {
++ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
++}
++
++}
++
++namespace Catch {
++
++ Approx::Approx ( double value )
++ : m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
++ m_margin( 0.0 ),
++ m_scale( 0.0 ),
++ m_value( value )
++ {}
++
++ Approx Approx::custom() {
++ return Approx( 0 );
++ }
++
++ Approx Approx::operator-() const {
++ auto temp(*this);
++ temp.m_value = -temp.m_value;
++ return temp;
++ }
++
++
++ std::string Approx::toString() const {
++ ReusableStringStream rss;
++ rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
++ return rss.str();
++ }
++
++ bool Approx::equalityComparisonImpl(const double other) const {
++ // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
++ // Thanks to Richard Harris for his help refining the scaled margin value
++ return marginComparison(m_value, other, m_margin)
++ || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
++ }
++
++ void Approx::setMargin(double newMargin) {
++ CATCH_ENFORCE(newMargin >= 0,
++ "Invalid Approx::margin: " << newMargin << '.'
++ << " Approx::Margin has to be non-negative.");
++ m_margin = newMargin;
++ }
++
++ void Approx::setEpsilon(double newEpsilon) {
++ CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
++ "Invalid Approx::epsilon: " << newEpsilon << '.'
++ << " Approx::epsilon has to be in [0, 1]");
++ m_epsilon = newEpsilon;
++ }
++
++namespace literals {
++ Approx operator ""_a(long double val) {
++ return Approx(val);
++ }
++ Approx operator ""_a(unsigned long long val) {
++ return Approx(val);
++ }
++} // end namespace literals
++
++std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
++ return value.toString();
++}
++
++} // end namespace Catch
++
++
++
++namespace Catch {
++
++ AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
++ lazyExpression(_lazyExpression),
++ resultType(_resultType) {}
++
++ std::string AssertionResultData::reconstructExpression() const {
++
++ if( reconstructedExpression.empty() ) {
++ if( lazyExpression ) {
++ ReusableStringStream rss;
++ rss << lazyExpression;
++ reconstructedExpression = rss.str();
++ }
++ }
++ return reconstructedExpression;
++ }
++
++ AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
++ : m_info( info ),
++ m_resultData( CATCH_MOVE(data) )
++ {}
++
++ // Result was a success
++ bool AssertionResult::succeeded() const {
++ return Catch::isOk( m_resultData.resultType );
++ }
++
++ // Result was a success, or failure is suppressed
++ bool AssertionResult::isOk() const {
++ return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
++ }
++
++ ResultWas::OfType AssertionResult::getResultType() const {
++ return m_resultData.resultType;
++ }
++
++ bool AssertionResult::hasExpression() const {
++ return !m_info.capturedExpression.empty();
++ }
++
++ bool AssertionResult::hasMessage() const {
++ return !m_resultData.message.empty();
++ }
++
++ std::string AssertionResult::getExpression() const {
++ // Possibly overallocating by 3 characters should be basically free
++ std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
++ if (isFalseTest(m_info.resultDisposition)) {
++ expr += "!(";
++ }
++ expr += m_info.capturedExpression;
++ if (isFalseTest(m_info.resultDisposition)) {
++ expr += ')';
++ }
++ return expr;
++ }
++
++ std::string AssertionResult::getExpressionInMacro() const {
++ if ( m_info.macroName.empty() ) {
++ return static_cast<std::string>( m_info.capturedExpression );
++ }
++ std::string expr;
++ expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
++ expr += m_info.macroName;
++ expr += "( ";
++ expr += m_info.capturedExpression;
++ expr += " )";
++ return expr;
++ }
++
++ bool AssertionResult::hasExpandedExpression() const {
++ return hasExpression() && getExpandedExpression() != getExpression();
++ }
++
++ std::string AssertionResult::getExpandedExpression() const {
++ std::string expr = m_resultData.reconstructExpression();
++ return expr.empty()
++ ? getExpression()
++ : expr;
++ }
++
++ StringRef AssertionResult::getMessage() const {
++ return m_resultData.message;
++ }
++ SourceLineInfo AssertionResult::getSourceInfo() const {
++ return m_info.lineInfo;
++ }
++
++ StringRef AssertionResult::getTestMacroName() const {
++ return m_info.macroName;
++ }
++
++} // end namespace Catch
++
++
++
++#include <fstream>
++
++namespace Catch {
++
++ namespace {
++ static bool enableBazelEnvSupport() {
++#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
++ return true;
++#else
++ return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
++#endif
++ }
++
++ struct bazelShardingOptions {
++ unsigned int shardIndex, shardCount;
++ std::string shardFilePath;
++ };
++
++ static Optional<bazelShardingOptions> readBazelShardingOptions() {
++ const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
++ const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
++ const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
++
++
++ const bool has_all =
++ bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
++ if ( !has_all ) {
++ // We provide nice warning message if the input is
++ // misconfigured.
++ auto warn = []( const char* env_var ) {
++ Catch::cerr()
++ << "Warning: Bazel shard configuration is missing '"
++ << env_var << "'. Shard configuration is skipped.\n";
++ };
++ if ( !bazelShardIndex ) {
++ warn( "TEST_SHARD_INDEX" );
++ }
++ if ( !bazelShardTotal ) {
++ warn( "TEST_TOTAL_SHARDS" );
++ }
++ if ( !bazelShardInfoFile ) {
++ warn( "TEST_SHARD_STATUS_FILE" );
++ }
++ return {};
++ }
++
++ auto shardIndex = parseUInt( bazelShardIndex );
++ if ( !shardIndex ) {
++ Catch::cerr()
++ << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
++ << "') as unsigned int.\n";
++ return {};
++ }
++ auto shardTotal = parseUInt( bazelShardTotal );
++ if ( !shardTotal ) {
++ Catch::cerr()
++ << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
++ << bazelShardTotal << "') as unsigned int.\n";
++ return {};
++ }
++
++ return bazelShardingOptions{
++ *shardIndex, *shardTotal, bazelShardInfoFile };
++
++ }
++ } // end namespace
++
++
++ bool operator==( ProcessedReporterSpec const& lhs,
++ ProcessedReporterSpec const& rhs ) {
++ return lhs.name == rhs.name &&
++ lhs.outputFilename == rhs.outputFilename &&
++ lhs.colourMode == rhs.colourMode &&
++ lhs.customOptions == rhs.customOptions;
++ }
++
++ Config::Config( ConfigData const& data ):
++ m_data( data ) {
++ // We need to trim filter specs to avoid trouble with superfluous
++ // whitespace (esp. important for bdd macros, as those are manually
++ // aligned with whitespace).
++
++ for (auto& elem : m_data.testsOrTags) {
++ elem = trim(elem);
++ }
++ for (auto& elem : m_data.sectionsToRun) {
++ elem = trim(elem);
++ }
++
++ // Insert the default reporter if user hasn't asked for a specific one
++ if ( m_data.reporterSpecifications.empty() ) {
++#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
++ const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
++#else
++ const auto default_spec = "console";
++#endif
++ auto parsed = parseReporterSpec(default_spec);
++ CATCH_ENFORCE( parsed,
++ "Cannot parse the provided default reporter spec: '"
++ << default_spec << '\'' );
++ m_data.reporterSpecifications.push_back( std::move( *parsed ) );
++ }
++
++ if ( enableBazelEnvSupport() ) {
++ readBazelEnvVars();
++ }
++
++ // Bazel support can modify the test specs, so parsing has to happen
++ // after reading Bazel env vars.
++ TestSpecParser parser( ITagAliasRegistry::get() );
++ if ( !m_data.testsOrTags.empty() ) {
++ m_hasTestFilters = true;
++ for ( auto const& testOrTags : m_data.testsOrTags ) {
++ parser.parse( testOrTags );
++ }
++ }
++ m_testSpec = parser.testSpec();
++
++
++ // We now fixup the reporter specs to handle default output spec,
++ // default colour spec, etc
++ bool defaultOutputUsed = false;
++ for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
++ // We do the default-output check separately, while always
++ // using the default output below to make the code simpler
++ // and avoid superfluous copies.
++ if ( reporterSpec.outputFile().none() ) {
++ CATCH_ENFORCE( !defaultOutputUsed,
++ "Internal error: cannot use default output for "
++ "multiple reporters" );
++ defaultOutputUsed = true;
++ }
++
++ m_processedReporterSpecs.push_back( ProcessedReporterSpec{
++ reporterSpec.name(),
++ reporterSpec.outputFile() ? *reporterSpec.outputFile()
++ : data.defaultOutputFilename,
++ reporterSpec.colourMode().valueOr( data.defaultColourMode ),
++ reporterSpec.customOptions() } );
++ }
++ }
++
++ Config::~Config() = default;
++
++
++ bool Config::listTests() const { return m_data.listTests; }
++ bool Config::listTags() const { return m_data.listTags; }
++ bool Config::listReporters() const { return m_data.listReporters; }
++ bool Config::listListeners() const { return m_data.listListeners; }
++
++ std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
++ std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
++
++ std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
++ return m_data.reporterSpecifications;
++ }
++
++ std::vector<ProcessedReporterSpec> const&
++ Config::getProcessedReporterSpecs() const {
++ return m_processedReporterSpecs;
++ }
++
++ TestSpec const& Config::testSpec() const { return m_testSpec; }
++ bool Config::hasTestFilters() const { return m_hasTestFilters; }
++
++ bool Config::showHelp() const { return m_data.showHelp; }
++
++ // IConfig interface
++ bool Config::allowThrows() const { return !m_data.noThrow; }
++ StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
++ bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
++ bool Config::warnAboutMissingAssertions() const {
++ return !!( m_data.warnings & WarnAbout::NoAssertions );
++ }
++ bool Config::warnAboutUnmatchedTestSpecs() const {
++ return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
++ }
++ bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; }
++ ShowDurations Config::showDurations() const { return m_data.showDurations; }
++ double Config::minDuration() const { return m_data.minDuration; }
++ TestRunOrder Config::runOrder() const { return m_data.runOrder; }
++ uint32_t Config::rngSeed() const { return m_data.rngSeed; }
++ unsigned int Config::shardCount() const { return m_data.shardCount; }
++ unsigned int Config::shardIndex() const { return m_data.shardIndex; }
++ ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; }
++ bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
++ int Config::abortAfter() const { return m_data.abortAfter; }
++ bool Config::showInvisibles() const { return m_data.showInvisibles; }
++ Verbosity Config::verbosity() const { return m_data.verbosity; }
++
++ bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; }
++ bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
++ unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
++ double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
++ unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
++ std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
++
++ void Config::readBazelEnvVars() {
++ // Register a JUnit reporter for Bazel. Bazel sets an environment
++ // variable with the path to XML output. If this file is written to
++ // during test, Bazel will not generate a default XML output.
++ // This allows the XML output file to contain higher level of detail
++ // than what is possible otherwise.
++ const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
++
++ if ( bazelOutputFile ) {
++ m_data.reporterSpecifications.push_back(
++ { "junit", std::string( bazelOutputFile ), {}, {} } );
++ }
++
++ const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
++ if ( bazelTestSpec ) {
++ // Presumably the test spec from environment should overwrite
++ // the one we got from CLI (if we got any)
++ m_data.testsOrTags.clear();
++ m_data.testsOrTags.push_back( bazelTestSpec );
++ }
++
++ const auto bazelShardOptions = readBazelShardingOptions();
++ if ( bazelShardOptions ) {
++ std::ofstream f( bazelShardOptions->shardFilePath,
++ std::ios_base::out | std::ios_base::trunc );
++ if ( f.is_open() ) {
++ f << "";
++ m_data.shardIndex = bazelShardOptions->shardIndex;
++ m_data.shardCount = bazelShardOptions->shardCount;
++ }
++ }
++ }
++
++} // end namespace Catch
++
++
++
++
++
++namespace Catch {
++ std::uint32_t getSeed() {
++ return getCurrentContext().getConfig()->rngSeed();
++ }
++}
++
++
++
++#include <cassert>
++#include <stack>
++
++namespace Catch {
++
++ ////////////////////////////////////////////////////////////////////////////
++
++
++ ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
++ m_info( CATCH_MOVE(builder.m_info) ) {
++ m_info.message = builder.m_stream.str();
++ getResultCapture().pushScopedMessage( m_info );
++ }
++
++ ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
++ m_info( CATCH_MOVE( old.m_info ) ) {
++ old.m_moved = true;
++ }
++
++ ScopedMessage::~ScopedMessage() {
++ if ( !uncaught_exceptions() && !m_moved ){
++ getResultCapture().popScopedMessage(m_info);
++ }
++ }
++
++
++ Capturer::Capturer( StringRef macroName,
++ SourceLineInfo const& lineInfo,
++ ResultWas::OfType resultType,
++ StringRef names ):
++ m_resultCapture( getResultCapture() ) {
++ auto trimmed = [&] (size_t start, size_t end) {
++ while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
++ ++start;
++ }
++ while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
++ --end;
++ }
++ return names.substr(start, end - start + 1);
++ };
++ auto skipq = [&] (size_t start, char quote) {
++ for (auto i = start + 1; i < names.size() ; ++i) {
++ if (names[i] == quote)
++ return i;
++ if (names[i] == '\\')
++ ++i;
++ }
++ CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
++ };
++
++ size_t start = 0;
++ std::stack<char> openings;
++ for (size_t pos = 0; pos < names.size(); ++pos) {
++ char c = names[pos];
++ switch (c) {
++ case '[':
++ case '{':
++ case '(':
++ // It is basically impossible to disambiguate between
++ // comparison and start of template args in this context
++// case '<':
++ openings.push(c);
++ break;
++ case ']':
++ case '}':
++ case ')':
++// case '>':
++ openings.pop();
++ break;
++ case '"':
++ case '\'':
++ pos = skipq(pos, c);
++ break;
++ case ',':
++ if (start != pos && openings.empty()) {
++ m_messages.emplace_back(macroName, lineInfo, resultType);
++ m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
++ m_messages.back().message += " := ";
++ start = pos;
++ }
++ default:; // noop
++ }
++ }
++ assert(openings.empty() && "Mismatched openings");
++ m_messages.emplace_back(macroName, lineInfo, resultType);
++ m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
++ m_messages.back().message += " := ";
++ }
++ Capturer::~Capturer() {
++ if ( !uncaught_exceptions() ){
++ assert( m_captured == m_messages.size() );
++ for( size_t i = 0; i < m_captured; ++i )
++ m_resultCapture.popScopedMessage( m_messages[i] );
++ }
++ }
++
++ void Capturer::captureValue( size_t index, std::string const& value ) {
++ assert( index < m_messages.size() );
++ m_messages[index].message += value;
++ m_resultCapture.pushScopedMessage( m_messages[index] );
++ m_captured++;
++ }
++
++} // end namespace Catch
++
++
++
++
++#include <exception>
++
++namespace Catch {
++
++ namespace {
++
++ class RegistryHub : public IRegistryHub,
++ public IMutableRegistryHub,
++ private Detail::NonCopyable {
++
++ public: // IRegistryHub
++ RegistryHub() = default;
++ ReporterRegistry const& getReporterRegistry() const override {
++ return m_reporterRegistry;
++ }
++ ITestCaseRegistry const& getTestCaseRegistry() const override {
++ return m_testCaseRegistry;
++ }
++ IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
++ return m_exceptionTranslatorRegistry;
++ }
++ ITagAliasRegistry const& getTagAliasRegistry() const override {
++ return m_tagAliasRegistry;
++ }
++ StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
++ return m_exceptionRegistry;
++ }
++
++ public: // IMutableRegistryHub
++ void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
++ m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
++ }
++ void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
++ m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
++ }
++ void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
++ m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
++ }
++ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
++ m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
++ }
++ void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
++ m_tagAliasRegistry.add( alias, tag, lineInfo );
++ }
++ void registerStartupException() noexcept override {
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ m_exceptionRegistry.add(std::current_exception());
++#else
++ CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
++#endif
++ }
++ IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
++ return m_enumValuesRegistry;
++ }
++
++ private:
++ TestRegistry m_testCaseRegistry;
++ ReporterRegistry m_reporterRegistry;
++ ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
++ TagAliasRegistry m_tagAliasRegistry;
++ StartupExceptionRegistry m_exceptionRegistry;
++ Detail::EnumValuesRegistry m_enumValuesRegistry;
++ };
++ }
++
++ using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
++
++ IRegistryHub const& getRegistryHub() {
++ return RegistryHubSingleton::get();
++ }
++ IMutableRegistryHub& getMutableRegistryHub() {
++ return RegistryHubSingleton::getMutable();
++ }
++ void cleanUp() {
++ cleanupSingletons();
++ cleanUpContext();
++ }
++ std::string translateActiveException() {
++ return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
++ }
++
++
++} // end namespace Catch
++
++
++
++#include <algorithm>
++#include <cassert>
++#include <exception>
++#include <iomanip>
++#include <set>
++
++namespace Catch {
++
++ namespace {
++ const int MaxExitCode = 255;
++
++ IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
++ auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
++ CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
++
++ return reporter;
++ }
++
++ IEventListenerPtr prepareReporters(Config const* config) {
++ if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
++ && config->getProcessedReporterSpecs().size() == 1) {
++ auto const& spec = config->getProcessedReporterSpecs()[0];
++ return createReporter(
++ spec.name,
++ ReporterConfig( config,
++ makeStream( spec.outputFilename ),
++ spec.colourMode,
++ spec.customOptions ) );
++ }
++
++ auto multi = Detail::make_unique<MultiReporter>(config);
++
++ auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
++ for (auto const& listener : listeners) {
++ multi->addListener(listener->create(config));
++ }
++
++ for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
++ multi->addReporter( createReporter(
++ reporterSpec.name,
++ ReporterConfig( config,
++ makeStream( reporterSpec.outputFilename ),
++ reporterSpec.colourMode,
++ reporterSpec.customOptions ) ) );
++ }
++
++ return multi;
++ }
++
++ class TestGroup {
++ public:
++ explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
++ m_reporter(reporter.get()),
++ m_config{config},
++ m_context{config, CATCH_MOVE(reporter)} {
++
++ assert( m_config->testSpec().getInvalidSpecs().empty() &&
++ "Invalid test specs should be handled before running tests" );
++
++ auto const& allTestCases = getAllTestCasesSorted(*m_config);
++ auto const& testSpec = m_config->testSpec();
++ if ( !testSpec.hasFilters() ) {
++ for ( auto const& test : allTestCases ) {
++ if ( !test.getTestCaseInfo().isHidden() ) {
++ m_tests.emplace( &test );
++ }
++ }
++ } else {
++ m_matches =
++ testSpec.matchesByFilter( allTestCases, *m_config );
++ for ( auto const& match : m_matches ) {
++ m_tests.insert( match.tests.begin(),
++ match.tests.end() );
++ }
++ }
++
++ m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
++ }
++
++ Totals execute() {
++ Totals totals;
++ for (auto const& testCase : m_tests) {
++ if (!m_context.aborting())
++ totals += m_context.runTest(*testCase);
++ else
++ m_reporter->skipTest(testCase->getTestCaseInfo());
++ }
++
++ for (auto const& match : m_matches) {
++ if (match.tests.empty()) {
++ m_unmatchedTestSpecs = true;
++ m_reporter->noMatchingTestCases( match.name );
++ }
++ }
++
++ return totals;
++ }
++
++ bool hadUnmatchedTestSpecs() const {
++ return m_unmatchedTestSpecs;
++ }
++
++
++ private:
++ IEventListener* m_reporter;
++ Config const* m_config;
++ RunContext m_context;
++ std::set<TestCaseHandle const*> m_tests;
++ TestSpec::Matches m_matches;
++ bool m_unmatchedTestSpecs = false;
++ };
++
++ void applyFilenamesAsTags() {
++ for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
++ testInfo->addFilenameTag();
++ }
++ }
++
++ } // anon namespace
++
++ Session::Session() {
++ static bool alreadyInstantiated = false;
++ if( alreadyInstantiated ) {
++ CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
++ CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
++ }
++
++ // There cannot be exceptions at startup in no-exception mode.
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
++ if ( !exceptions.empty() ) {
++ config();
++ getCurrentMutableContext().setConfig(m_config.get());
++
++ m_startupExceptions = true;
++ auto errStream = makeStream( "%stderr" );
++ auto colourImpl = makeColourImpl(
++ ColourMode::PlatformDefault, errStream.get() );
++ auto guard = colourImpl->guardColour( Colour::Red );
++ errStream->stream() << "Errors occurred during startup!" << '\n';
++ // iterate over all exceptions and notify user
++ for ( const auto& ex_ptr : exceptions ) {
++ try {
++ std::rethrow_exception(ex_ptr);
++ } catch ( std::exception const& ex ) {
++ errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
++ }
++ }
++ }
++#endif
++
++ alreadyInstantiated = true;
++ m_cli = makeCommandLineParser( m_configData );
++ }
++ Session::~Session() {
++ Catch::cleanUp();
++ }
++
++ void Session::showHelp() const {
++ Catch::cout()
++ << "\nCatch2 v" << libraryVersion() << '\n'
++ << m_cli << '\n'
++ << "For more detailed usage please see the project docs\n\n" << std::flush;
++ }
++ void Session::libIdentify() {
++ Catch::cout()
++ << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
++ << std::left << std::setw(16) << "category: " << "testframework\n"
++ << std::left << std::setw(16) << "framework: " << "Catch2\n"
++ << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
++ }
++
++ int Session::applyCommandLine( int argc, char const * const * argv ) {
++ if( m_startupExceptions )
++ return 1;
++
++ auto result = m_cli.parse( Clara::Args( argc, argv ) );
++
++ if( !result ) {
++ config();
++ getCurrentMutableContext().setConfig(m_config.get());
++ auto errStream = makeStream( "%stderr" );
++ auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
++
++ errStream->stream()
++ << colour->guardColour( Colour::Red )
++ << "\nError(s) in input:\n"
++ << TextFlow::Column( result.errorMessage() ).indent( 2 )
++ << "\n\n";
++ errStream->stream() << "Run with -? for usage\n\n" << std::flush;
++ return MaxExitCode;
++ }
++
++ if( m_configData.showHelp )
++ showHelp();
++ if( m_configData.libIdentify )
++ libIdentify();
++
++ m_config.reset();
++ return 0;
++ }
++
++#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
++ int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
++
++ char **utf8Argv = new char *[ argc ];
++
++ for ( int i = 0; i < argc; ++i ) {
++ int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
++
++ utf8Argv[ i ] = new char[ bufSize ];
++
++ WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
++ }
++
++ int returnCode = applyCommandLine( argc, utf8Argv );
++
++ for ( int i = 0; i < argc; ++i )
++ delete [] utf8Argv[ i ];
++
++ delete [] utf8Argv;
++
++ return returnCode;
++ }
++#endif
++
++ void Session::useConfigData( ConfigData const& configData ) {
++ m_configData = configData;
++ m_config.reset();
++ }
++
++ int Session::run() {
++ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
++ Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
++ static_cast<void>(std::getchar());
++ }
++ int exitCode = runInternal();
++ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
++ Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
++ static_cast<void>(std::getchar());
++ }
++ return exitCode;
++ }
++
++ Clara::Parser const& Session::cli() const {
++ return m_cli;
++ }
++ void Session::cli( Clara::Parser const& newParser ) {
++ m_cli = newParser;
++ }
++ ConfigData& Session::configData() {
++ return m_configData;
++ }
++ Config& Session::config() {
++ if( !m_config )
++ m_config = Detail::make_unique<Config>( m_configData );
++ return *m_config;
++ }
++
++ int Session::runInternal() {
++ if( m_startupExceptions )
++ return 1;
++
++ if (m_configData.showHelp || m_configData.libIdentify) {
++ return 0;
++ }
++
++ if ( m_configData.shardIndex >= m_configData.shardCount ) {
++ Catch::cerr() << "The shard count (" << m_configData.shardCount
++ << ") must be greater than the shard index ("
++ << m_configData.shardIndex << ")\n"
++ << std::flush;
++ return 1;
++ }
++
++ CATCH_TRY {
++ config(); // Force config to be constructed
++
++ seedRng( *m_config );
++
++ if (m_configData.filenamesAsTags) {
++ applyFilenamesAsTags();
++ }
++
++ // Set up global config instance before we start calling into other functions
++ getCurrentMutableContext().setConfig(m_config.get());
++
++ // Create reporter(s) so we can route listings through them
++ auto reporter = prepareReporters(m_config.get());
++
++ auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
++ if ( !invalidSpecs.empty() ) {
++ for ( auto const& spec : invalidSpecs ) {
++ reporter->reportInvalidTestSpec( spec );
++ }
++ return 1;
++ }
++
++
++ // Handle list request
++ if (list(*reporter, *m_config)) {
++ return 0;
++ }
++
++ TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
++ auto const totals = tests.execute();
++
++ if ( tests.hadUnmatchedTestSpecs()
++ && m_config->warnAboutUnmatchedTestSpecs() ) {
++ return 3;
++ }
++
++ if ( totals.testCases.total() == 0
++ && !m_config->zeroTestsCountAsSuccess() ) {
++ return 2;
++ }
++
++ if ( totals.testCases.total() > 0 &&
++ totals.testCases.total() == totals.testCases.skipped
++ && !m_config->zeroTestsCountAsSuccess() ) {
++ return 4;
++ }
++
++ // Note that on unices only the lower 8 bits are usually used, clamping
++ // the return value to 255 prevents false negative when some multiple
++ // of 256 tests has failed
++ return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
++ }
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ catch( std::exception& ex ) {
++ Catch::cerr() << ex.what() << '\n' << std::flush;
++ return MaxExitCode;
++ }
++#endif
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++
++ RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
++ CATCH_TRY {
++ getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
++ } CATCH_CATCH_ALL {
++ // Do not throw when constructing global objects, instead register the exception to be processed later
++ getMutableRegistryHub().registerStartupException();
++ }
++ }
++
++}
++
++
++
++#include <cassert>
++#include <cctype>
++#include <algorithm>
++
++namespace Catch {
++
++ namespace {
++ using TCP_underlying_type = uint8_t;
++ static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
++ "The size of the TestCaseProperties is different from the assumed size");
++
++ TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
++ return static_cast<TestCaseProperties>(
++ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
++ );
++ }
++
++ TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
++ lhs = static_cast<TestCaseProperties>(
++ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
++ );
++ return lhs;
++ }
++
++ TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
++ return static_cast<TestCaseProperties>(
++ static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
++ );
++ }
++
++ bool applies(TestCaseProperties tcp) {
++ static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
++ "TestCaseProperties::None must be equal to 0");
++ return tcp != TestCaseProperties::None;
++ }
++
++ TestCaseProperties parseSpecialTag( StringRef tag ) {
++ if( !tag.empty() && tag[0] == '.' )
++ return TestCaseProperties::IsHidden;
++ else if( tag == "!throws"_sr )
++ return TestCaseProperties::Throws;
++ else if( tag == "!shouldfail"_sr )
++ return TestCaseProperties::ShouldFail;
++ else if( tag == "!mayfail"_sr )
++ return TestCaseProperties::MayFail;
++ else if( tag == "!nonportable"_sr )
++ return TestCaseProperties::NonPortable;
++ else if( tag == "!benchmark"_sr )
++ return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
++ else
++ return TestCaseProperties::None;
++ }
++ bool isReservedTag( StringRef tag ) {
++ return parseSpecialTag( tag ) == TestCaseProperties::None
++ && tag.size() > 0
++ && !std::isalnum( static_cast<unsigned char>(tag[0]) );
++ }
++ void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
++ CATCH_ENFORCE( !isReservedTag(tag),
++ "Tag name: [" << tag << "] is not allowed.\n"
++ << "Tag names starting with non alphanumeric characters are reserved\n"
++ << _lineInfo );
++ }
++
++ std::string makeDefaultName() {
++ static size_t counter = 0;
++ return "Anonymous test case " + std::to_string(++counter);
++ }
++
++ StringRef extractFilenamePart(StringRef filename) {
++ size_t lastDot = filename.size();
++ while (lastDot > 0 && filename[lastDot - 1] != '.') {
++ --lastDot;
++ }
++ // In theory we could have filename without any extension in it
++ if ( lastDot == 0 ) { return StringRef(); }
++
++ --lastDot;
++ size_t nameStart = lastDot;
++ while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
++ --nameStart;
++ }
++
++ return filename.substr(nameStart, lastDot - nameStart);
++ }
++
++ // Returns the upper bound on size of extra tags ([#file]+[.])
++ size_t sizeOfExtraTags(StringRef filepath) {
++ // [.] is 3, [#] is another 3
++ const size_t extras = 3 + 3;
++ return extractFilenamePart(filepath).size() + extras;
++ }
++ } // end unnamed namespace
++
++ bool operator<( Tag const& lhs, Tag const& rhs ) {
++ Detail::CaseInsensitiveLess cmp;
++ return cmp( lhs.original, rhs.original );
++ }
++ bool operator==( Tag const& lhs, Tag const& rhs ) {
++ Detail::CaseInsensitiveEqualTo cmp;
++ return cmp( lhs.original, rhs.original );
++ }
++
++ Detail::unique_ptr<TestCaseInfo>
++ makeTestCaseInfo(StringRef _className,
++ NameAndTags const& nameAndTags,
++ SourceLineInfo const& _lineInfo ) {
++ return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
++ }
++
++ TestCaseInfo::TestCaseInfo(StringRef _className,
++ NameAndTags const& _nameAndTags,
++ SourceLineInfo const& _lineInfo):
++ name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
++ className( _className ),
++ lineInfo( _lineInfo )
++ {
++ StringRef originalTags = _nameAndTags.tags;
++ // We need to reserve enough space to store all of the tags
++ // (including optional hidden tag and filename tag)
++ auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
++ backingTags.reserve(requiredSize);
++
++ // We cannot copy the tags directly, as we need to normalize
++ // some tags, so that [.foo] is copied as [.][foo].
++ size_t tagStart = 0;
++ size_t tagEnd = 0;
++ bool inTag = false;
++ for (size_t idx = 0; idx < originalTags.size(); ++idx) {
++ auto c = originalTags[idx];
++ if (c == '[') {
++ CATCH_ENFORCE(
++ !inTag,
++ "Found '[' inside a tag while registering test case '"
++ << _nameAndTags.name << "' at " << _lineInfo );
++
++ inTag = true;
++ tagStart = idx;
++ }
++ if (c == ']') {
++ CATCH_ENFORCE(
++ inTag,
++ "Found unmatched ']' while registering test case '"
++ << _nameAndTags.name << "' at " << _lineInfo );
++
++ inTag = false;
++ tagEnd = idx;
++ assert(tagStart < tagEnd);
++
++ // We need to check the tag for special meanings, copy
++ // it over to backing storage and actually reference the
++ // backing storage in the saved tags
++ StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
++ CATCH_ENFORCE( !tagStr.empty(),
++ "Found an empty tag while registering test case '"
++ << _nameAndTags.name << "' at "
++ << _lineInfo );
++
++ enforceNotReservedTag(tagStr, lineInfo);
++ properties |= parseSpecialTag(tagStr);
++ // When copying a tag to the backing storage, we need to
++ // check if it is a merged hide tag, such as [.foo], and
++ // if it is, we need to handle it as if it was [foo].
++ if (tagStr.size() > 1 && tagStr[0] == '.') {
++ tagStr = tagStr.substr(1, tagStr.size() - 1);
++ }
++ // We skip over dealing with the [.] tag, as we will add
++ // it later unconditionally and then sort and unique all
++ // the tags.
++ internalAppendTag(tagStr);
++ }
++ }
++ CATCH_ENFORCE( !inTag,
++ "Found an unclosed tag while registering test case '"
++ << _nameAndTags.name << "' at " << _lineInfo );
++
++
++ // Add [.] if relevant
++ if (isHidden()) {
++ internalAppendTag("."_sr);
++ }
++
++ // Sort and prepare tags
++ std::sort(begin(tags), end(tags));
++ tags.erase(std::unique(begin(tags), end(tags)),
++ end(tags));
++ }
++
++ bool TestCaseInfo::isHidden() const {
++ return applies( properties & TestCaseProperties::IsHidden );
++ }
++ bool TestCaseInfo::throws() const {
++ return applies( properties & TestCaseProperties::Throws );
++ }
++ bool TestCaseInfo::okToFail() const {
++ return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
++ }
++ bool TestCaseInfo::expectedToFail() const {
++ return applies( properties & (TestCaseProperties::ShouldFail) );
++ }
++
++ void TestCaseInfo::addFilenameTag() {
++ std::string combined("#");
++ combined += extractFilenamePart(lineInfo.file);
++ internalAppendTag(combined);
++ }
++
++ std::string TestCaseInfo::tagsAsString() const {
++ std::string ret;
++ // '[' and ']' per tag
++ std::size_t full_size = 2 * tags.size();
++ for (const auto& tag : tags) {
++ full_size += tag.original.size();
++ }
++ ret.reserve(full_size);
++ for (const auto& tag : tags) {
++ ret.push_back('[');
++ ret += tag.original;
++ ret.push_back(']');
++ }
++
++ return ret;
++ }
++
++ void TestCaseInfo::internalAppendTag(StringRef tagStr) {
++ backingTags += '[';
++ const auto backingStart = backingTags.size();
++ backingTags += tagStr;
++ const auto backingEnd = backingTags.size();
++ backingTags += ']';
++ tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
++ }
++
++ bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
++ // We want to avoid redoing the string comparisons multiple times,
++ // so we store the result of a three-way comparison before using
++ // it in the actual comparison logic.
++ const auto cmpName = lhs.name.compare( rhs.name );
++ if ( cmpName != 0 ) {
++ return cmpName < 0;
++ }
++ const auto cmpClassName = lhs.className.compare( rhs.className );
++ if ( cmpClassName != 0 ) {
++ return cmpClassName < 0;
++ }
++ return lhs.tags < rhs.tags;
++ }
++
++ TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
++ return *m_info;
++ }
++
++} // end namespace Catch
++
++
++
++#include <algorithm>
++#include <string>
++#include <vector>
++#include <ostream>
++
++namespace Catch {
++
++ TestSpec::Pattern::Pattern( std::string const& name )
++ : m_name( name )
++ {}
++
++ TestSpec::Pattern::~Pattern() = default;
++
++ std::string const& TestSpec::Pattern::name() const {
++ return m_name;
++ }
++
++
++ TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
++ : Pattern( filterString )
++ , m_wildcardPattern( toLower( name ), CaseSensitive::No )
++ {}
++
++ bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
++ return m_wildcardPattern.matches( testCase.name );
++ }
++
++ void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
++ out << '"' << name() << '"';
++ }
++
++
++ TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
++ : Pattern( filterString )
++ , m_tag( tag )
++ {}
++
++ bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
++ return std::find( begin( testCase.tags ),
++ end( testCase.tags ),
++ Tag( m_tag ) ) != end( testCase.tags );
++ }
++
++ void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
++ out << name();
++ }
++
++ bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
++ bool should_use = !testCase.isHidden();
++ for (auto const& pattern : m_required) {
++ should_use = true;
++ if (!pattern->matches(testCase)) {
++ return false;
++ }
++ }
++ for (auto const& pattern : m_forbidden) {
++ if (pattern->matches(testCase)) {
++ return false;
++ }
++ }
++ return should_use;
++ }
++
++ void TestSpec::Filter::serializeTo( std::ostream& out ) const {
++ bool first = true;
++ for ( auto const& pattern : m_required ) {
++ if ( !first ) {
++ out << ' ';
++ }
++ out << *pattern;
++ first = false;
++ }
++ for ( auto const& pattern : m_forbidden ) {
++ if ( !first ) {
++ out << ' ';
++ }
++ out << *pattern;
++ first = false;
++ }
++ }
++
++
++ std::string TestSpec::extractFilterName( Filter const& filter ) {
++ Catch::ReusableStringStream sstr;
++ sstr << filter;
++ return sstr.str();
++ }
++
++ bool TestSpec::hasFilters() const {
++ return !m_filters.empty();
++ }
++
++ bool TestSpec::matches( TestCaseInfo const& testCase ) const {
++ return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
++ }
++
++ TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
++ Matches matches;
++ matches.reserve( m_filters.size() );
++ for ( auto const& filter : m_filters ) {
++ std::vector<TestCaseHandle const*> currentMatches;
++ for ( auto const& test : testCases )
++ if ( isThrowSafe( test, config ) &&
++ filter.matches( test.getTestCaseInfo() ) )
++ currentMatches.emplace_back( &test );
++ matches.push_back(
++ FilterMatch{ extractFilterName( filter ), currentMatches } );
++ }
++ return matches;
++ }
++
++ const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
++ return m_invalidSpecs;
++ }
++
++ void TestSpec::serializeTo( std::ostream& out ) const {
++ bool first = true;
++ for ( auto const& filter : m_filters ) {
++ if ( !first ) {
++ out << ',';
++ }
++ out << filter;
++ first = false;
++ }
++ }
++
++}
++
++
++
++#include <chrono>
++
++namespace Catch {
++
++ namespace {
++ static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
++ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
++ }
++ } // end unnamed namespace
++
++ void Timer::start() {
++ m_nanoseconds = getCurrentNanosecondsSinceEpoch();
++ }
++ auto Timer::getElapsedNanoseconds() const -> uint64_t {
++ return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
++ }
++ auto Timer::getElapsedMicroseconds() const -> uint64_t {
++ return getElapsedNanoseconds()/1000;
++ }
++ auto Timer::getElapsedMilliseconds() const -> unsigned int {
++ return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
++ }
++ auto Timer::getElapsedSeconds() const -> double {
++ return getElapsedMicroseconds()/1000000.0;
++ }
++
++
++} // namespace Catch
++
++
++
++
++#include <cmath>
++#include <iomanip>
++
++namespace Catch {
++
++namespace Detail {
++
++ namespace {
++ const int hexThreshold = 255;
++
++ struct Endianness {
++ enum Arch { Big, Little };
++
++ static Arch which() {
++ int one = 1;
++ // If the lowest byte we read is non-zero, we can assume
++ // that little endian format is used.
++ auto value = *reinterpret_cast<char*>(&one);
++ return value ? Little : Big;
++ }
++ };
++
++ template<typename T>
++ std::string fpToString(T value, int precision) {
++ if (Catch::isnan(value)) {
++ return "nan";
++ }
++
++ ReusableStringStream rss;
++ rss << std::setprecision(precision)
++ << std::fixed
++ << value;
++ std::string d = rss.str();
++ std::size_t i = d.find_last_not_of('0');
++ if (i != std::string::npos && i != d.size() - 1) {
++ if (d[i] == '.')
++ i++;
++ d = d.substr(0, i + 1);
++ }
++ return d;
++ }
++ } // end unnamed namespace
++
++ std::string convertIntoString(StringRef string, bool escapeInvisibles) {
++ std::string ret;
++ // This is enough for the "don't escape invisibles" case, and a good
++ // lower bound on the "escape invisibles" case.
++ ret.reserve(string.size() + 2);
++
++ if (!escapeInvisibles) {
++ ret += '"';
++ ret += string;
++ ret += '"';
++ return ret;
++ }
++
++ ret += '"';
++ for (char c : string) {
++ switch (c) {
++ case '\r':
++ ret.append("\\r");
++ break;
++ case '\n':
++ ret.append("\\n");
++ break;
++ case '\t':
++ ret.append("\\t");
++ break;
++ case '\f':
++ ret.append("\\f");
++ break;
++ default:
++ ret.push_back(c);
++ break;
++ }
++ }
++ ret += '"';
++
++ return ret;
++ }
++
++ std::string convertIntoString(StringRef string) {
++ return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
++ }
++
++ std::string rawMemoryToString( const void *object, std::size_t size ) {
++ // Reverse order for little endian architectures
++ int i = 0, end = static_cast<int>( size ), inc = 1;
++ if( Endianness::which() == Endianness::Little ) {
++ i = end-1;
++ end = inc = -1;
++ }
++
++ unsigned char const *bytes = static_cast<unsigned char const *>(object);
++ ReusableStringStream rss;
++ rss << "0x" << std::setfill('0') << std::hex;
++ for( ; i != end; i += inc )
++ rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
++ return rss.str();
++ }
++} // end Detail namespace
++
++
++
++//// ======================================================= ////
++//
++// Out-of-line defs for full specialization of StringMaker
++//
++//// ======================================================= ////
++
++std::string StringMaker<std::string>::convert(const std::string& str) {
++ return Detail::convertIntoString( str );
++}
++
++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
++std::string StringMaker<std::string_view>::convert(std::string_view str) {
++ return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
++}
++#endif
++
++std::string StringMaker<char const*>::convert(char const* str) {
++ if (str) {
++ return Detail::convertIntoString( str );
++ } else {
++ return{ "{null string}" };
++ }
++}
++std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
++ if (str) {
++ return Detail::convertIntoString( str );
++ } else {
++ return{ "{null string}" };
++ }
++}
++
++#ifdef CATCH_CONFIG_WCHAR
++std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
++ std::string s;
++ s.reserve(wstr.size());
++ for (auto c : wstr) {
++ s += (c <= 0xff) ? static_cast<char>(c) : '?';
++ }
++ return ::Catch::Detail::stringify(s);
++}
++
++# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
++std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
++ return StringMaker<std::wstring>::convert(std::wstring(str));
++}
++# endif
++
++std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
++ if (str) {
++ return ::Catch::Detail::stringify(std::wstring{ str });
++ } else {
++ return{ "{null string}" };
++ }
++}
++std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
++ if (str) {
++ return ::Catch::Detail::stringify(std::wstring{ str });
++ } else {
++ return{ "{null string}" };
++ }
++}
++#endif
++
++#if defined(CATCH_CONFIG_CPP17_BYTE)
++#include <cstddef>
++std::string StringMaker<std::byte>::convert(std::byte value) {
++ return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
++}
++#endif // defined(CATCH_CONFIG_CPP17_BYTE)
++
++std::string StringMaker<int>::convert(int value) {
++ return ::Catch::Detail::stringify(static_cast<long long>(value));
++}
++std::string StringMaker<long>::convert(long value) {
++ return ::Catch::Detail::stringify(static_cast<long long>(value));
++}
++std::string StringMaker<long long>::convert(long long value) {
++ ReusableStringStream rss;
++ rss << value;
++ if (value > Detail::hexThreshold) {
++ rss << " (0x" << std::hex << value << ')';
++ }
++ return rss.str();
++}
++
++std::string StringMaker<unsigned int>::convert(unsigned int value) {
++ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
++}
++std::string StringMaker<unsigned long>::convert(unsigned long value) {
++ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
++}
++std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
++ ReusableStringStream rss;
++ rss << value;
++ if (value > Detail::hexThreshold) {
++ rss << " (0x" << std::hex << value << ')';
++ }
++ return rss.str();
++}
++
++std::string StringMaker<signed char>::convert(signed char value) {
++ if (value == '\r') {
++ return "'\\r'";
++ } else if (value == '\f') {
++ return "'\\f'";
++ } else if (value == '\n') {
++ return "'\\n'";
++ } else if (value == '\t') {
++ return "'\\t'";
++ } else if ('\0' <= value && value < ' ') {
++ return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
++ } else {
++ char chstr[] = "' '";
++ chstr[1] = value;
++ return chstr;
++ }
++}
++std::string StringMaker<char>::convert(char c) {
++ return ::Catch::Detail::stringify(static_cast<signed char>(c));
++}
++std::string StringMaker<unsigned char>::convert(unsigned char value) {
++ return ::Catch::Detail::stringify(static_cast<char>(value));
++}
++
++int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
++
++std::string StringMaker<float>::convert(float value) {
++ return Detail::fpToString(value, precision) + 'f';
++}
++
++int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
++
++std::string StringMaker<double>::convert(double value) {
++ return Detail::fpToString(value, precision);
++}
++
++} // end namespace Catch
++
++
++
++namespace Catch {
++
++ Counts Counts::operator - ( Counts const& other ) const {
++ Counts diff;
++ diff.passed = passed - other.passed;
++ diff.failed = failed - other.failed;
++ diff.failedButOk = failedButOk - other.failedButOk;
++ diff.skipped = skipped - other.skipped;
++ return diff;
++ }
++
++ Counts& Counts::operator += ( Counts const& other ) {
++ passed += other.passed;
++ failed += other.failed;
++ failedButOk += other.failedButOk;
++ skipped += other.skipped;
++ return *this;
++ }
++
++ std::uint64_t Counts::total() const {
++ return passed + failed + failedButOk + skipped;
++ }
++ bool Counts::allPassed() const {
++ return failed == 0 && failedButOk == 0 && skipped == 0;
++ }
++ bool Counts::allOk() const {
++ return failed == 0;
++ }
++
++ Totals Totals::operator - ( Totals const& other ) const {
++ Totals diff;
++ diff.assertions = assertions - other.assertions;
++ diff.testCases = testCases - other.testCases;
++ return diff;
++ }
++
++ Totals& Totals::operator += ( Totals const& other ) {
++ assertions += other.assertions;
++ testCases += other.testCases;
++ return *this;
++ }
++
++ Totals Totals::delta( Totals const& prevTotals ) const {
++ Totals diff = *this - prevTotals;
++ if( diff.assertions.failed > 0 )
++ ++diff.testCases.failed;
++ else if( diff.assertions.failedButOk > 0 )
++ ++diff.testCases.failedButOk;
++ else if ( diff.assertions.skipped > 0 )
++ ++ diff.testCases.skipped;
++ else
++ ++diff.testCases.passed;
++ return diff;
++ }
++
++}
++
++
++
++
++namespace Catch {
++ namespace Detail {
++ void registerTranslatorImpl(
++ Detail::unique_ptr<IExceptionTranslator>&& translator ) {
++ getMutableRegistryHub().registerTranslator(
++ CATCH_MOVE( translator ) );
++ }
++ } // namespace Detail
++} // namespace Catch
++
++
++#include <ostream>
++
++namespace Catch {
++
++ Version::Version
++ ( unsigned int _majorVersion,
++ unsigned int _minorVersion,
++ unsigned int _patchNumber,
++ char const * const _branchName,
++ unsigned int _buildNumber )
++ : majorVersion( _majorVersion ),
++ minorVersion( _minorVersion ),
++ patchNumber( _patchNumber ),
++ branchName( _branchName ),
++ buildNumber( _buildNumber )
++ {}
++
++ std::ostream& operator << ( std::ostream& os, Version const& version ) {
++ os << version.majorVersion << '.'
++ << version.minorVersion << '.'
++ << version.patchNumber;
++ // branchName is never null -> 0th char is \0 if it is empty
++ if (version.branchName[0]) {
++ os << '-' << version.branchName
++ << '.' << version.buildNumber;
++ }
++ return os;
++ }
++
++ Version const& libraryVersion() {
++ static Version version( 3, 6, 0, "", 0 );
++ return version;
++ }
++
++}
++
++
++
++
++namespace Catch {
++
++ const char* GeneratorException::what() const noexcept {
++ return m_msg;
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++
++ IGeneratorTracker::~IGeneratorTracker() = default;
++
++namespace Generators {
++
++namespace Detail {
++
++ [[noreturn]]
++ void throw_generator_exception(char const* msg) {
++ Catch::throw_exception(GeneratorException{ msg });
++ }
++} // end namespace Detail
++
++ GeneratorUntypedBase::~GeneratorUntypedBase() = default;
++
++ IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
++ return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
++ }
++
++ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
++ SourceLineInfo lineInfo,
++ GeneratorBasePtr&& generator ) {
++ return getResultCapture().createGeneratorTracker(
++ generatorName, lineInfo, CATCH_MOVE( generator ) );
++ }
++
++} // namespace Generators
++} // namespace Catch
++
++
++
++
++#include <random>
++
++namespace Catch {
++ namespace Generators {
++ namespace Detail {
++ std::uint32_t getSeed() { return sharedRng()(); }
++ } // namespace Detail
++
++ struct RandomFloatingGenerator<long double>::PImpl {
++ PImpl( long double a, long double b, uint32_t seed ):
++ rng( seed ), dist( a, b ) {}
++
++ Catch::SimplePcg32 rng;
++ std::uniform_real_distribution<long double> dist;
++ };
++
++ RandomFloatingGenerator<long double>::RandomFloatingGenerator(
++ long double a, long double b, std::uint32_t seed) :
++ m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
++ static_cast<void>( next() );
++ }
++
++ RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
++ default;
++ bool RandomFloatingGenerator<long double>::next() {
++ m_current_number = m_pimpl->dist( m_pimpl->rng );
++ return true;
++ }
++ } // namespace Generators
++} // namespace Catch
++
++
++
++
++namespace Catch {
++ IResultCapture::~IResultCapture() = default;
++}
++
++
++
++
++namespace Catch {
++ IConfig::~IConfig() = default;
++}
++
++
++
++
++namespace Catch {
++ IExceptionTranslator::~IExceptionTranslator() = default;
++ IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
++}
++
++
++
++#include <string>
++
++namespace Catch {
++ namespace Generators {
++
++ bool GeneratorUntypedBase::countedNext() {
++ auto ret = next();
++ if ( ret ) {
++ m_stringReprCache.clear();
++ ++m_currentElementIndex;
++ }
++ return ret;
++ }
++
++ StringRef GeneratorUntypedBase::currentElementAsString() const {
++ if ( m_stringReprCache.empty() ) {
++ m_stringReprCache = stringifyImpl();
++ }
++ return m_stringReprCache;
++ }
++
++ } // namespace Generators
++} // namespace Catch
++
++
++
++
++namespace Catch {
++ IRegistryHub::~IRegistryHub() = default;
++ IMutableRegistryHub::~IMutableRegistryHub() = default;
++}
++
++
++
++#include <cassert>
++
++namespace Catch {
++
++ ReporterConfig::ReporterConfig(
++ IConfig const* _fullConfig,
++ Detail::unique_ptr<IStream> _stream,
++ ColourMode colourMode,
++ std::map<std::string, std::string> customOptions ):
++ m_stream( CATCH_MOVE(_stream) ),
++ m_fullConfig( _fullConfig ),
++ m_colourMode( colourMode ),
++ m_customOptions( CATCH_MOVE( customOptions ) ) {}
++
++ Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
++ assert( m_stream );
++ return CATCH_MOVE( m_stream );
++ }
++ IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
++ ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
++
++ std::map<std::string, std::string> const&
++ ReporterConfig::customOptions() const {
++ return m_customOptions;
++ }
++
++ ReporterConfig::~ReporterConfig() = default;
++
++ AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
++ std::vector<MessageInfo> const& _infoMessages,
++ Totals const& _totals )
++ : assertionResult( _assertionResult ),
++ infoMessages( _infoMessages ),
++ totals( _totals )
++ {
++ if( assertionResult.hasMessage() ) {
++ // Copy message into messages list.
++ // !TBD This should have been done earlier, somewhere
++ MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
++ builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
++
++ infoMessages.push_back( CATCH_MOVE(builder.m_info) );
++ }
++ }
++
++ SectionStats::SectionStats( SectionInfo&& _sectionInfo,
++ Counts const& _assertions,
++ double _durationInSeconds,
++ bool _missingAssertions )
++ : sectionInfo( CATCH_MOVE(_sectionInfo) ),
++ assertions( _assertions ),
++ durationInSeconds( _durationInSeconds ),
++ missingAssertions( _missingAssertions )
++ {}
++
++
++ TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
++ Totals const& _totals,
++ std::string&& _stdOut,
++ std::string&& _stdErr,
++ bool _aborting )
++ : testInfo( &_testInfo ),
++ totals( _totals ),
++ stdOut( CATCH_MOVE(_stdOut) ),
++ stdErr( CATCH_MOVE(_stdErr) ),
++ aborting( _aborting )
++ {}
++
++
++ TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
++ Totals const& _totals,
++ bool _aborting )
++ : runInfo( _runInfo ),
++ totals( _totals ),
++ aborting( _aborting )
++ {}
++
++ IEventListener::~IEventListener() = default;
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++ IReporterFactory::~IReporterFactory() = default;
++ EventListenerFactory::~EventListenerFactory() = default;
++}
++
++
++
++
++namespace Catch {
++ ITestCaseRegistry::~ITestCaseRegistry() = default;
++}
++
++
++
++namespace Catch {
++
++ AssertionHandler::AssertionHandler
++ ( StringRef macroName,
++ SourceLineInfo const& lineInfo,
++ StringRef capturedExpression,
++ ResultDisposition::Flags resultDisposition )
++ : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
++ m_resultCapture( getResultCapture() )
++ {
++ m_resultCapture.notifyAssertionStarted( m_assertionInfo );
++ }
++
++ void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
++ m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
++ }
++ void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
++ m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
++ }
++
++ auto AssertionHandler::allowThrows() const -> bool {
++ return getCurrentContext().getConfig()->allowThrows();
++ }
++
++ void AssertionHandler::complete() {
++ m_completed = true;
++ if( m_reaction.shouldDebugBreak ) {
++
++ // If you find your debugger stopping you here then go one level up on the
++ // call-stack for the code that caused it (typically a failed assertion)
++
++ // (To go back to the test and change execution, jump over the throw, next)
++ CATCH_BREAK_INTO_DEBUGGER();
++ }
++ if (m_reaction.shouldThrow) {
++ throw_test_failure_exception();
++ }
++ if ( m_reaction.shouldSkip ) {
++ throw_test_skip_exception();
++ }
++ }
++
++ void AssertionHandler::handleUnexpectedInflightException() {
++ m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
++ }
++
++ void AssertionHandler::handleExceptionThrownAsExpected() {
++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
++ }
++ void AssertionHandler::handleExceptionNotThrownAsExpected() {
++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
++ }
++
++ void AssertionHandler::handleUnexpectedExceptionNotThrown() {
++ m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
++ }
++
++ void AssertionHandler::handleThrowingCallSkipped() {
++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
++ }
++
++ // This is the overload that takes a string and infers the Equals matcher from it
++ // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
++ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
++ handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
++ }
++
++} // namespace Catch
++
++
++
++
++#include <algorithm>
++
++namespace Catch {
++ namespace Detail {
++
++ bool CaseInsensitiveLess::operator()( StringRef lhs,
++ StringRef rhs ) const {
++ return std::lexicographical_compare(
++ lhs.begin(), lhs.end(),
++ rhs.begin(), rhs.end(),
++ []( char l, char r ) { return toLower( l ) < toLower( r ); } );
++ }
++
++ bool
++ CaseInsensitiveEqualTo::operator()( StringRef lhs,
++ StringRef rhs ) const {
++ return std::equal(
++ lhs.begin(), lhs.end(),
++ rhs.begin(), rhs.end(),
++ []( char l, char r ) { return toLower( l ) == toLower( r ); } );
++ }
++
++ } // namespace Detail
++} // namespace Catch
++
++
++
++
++#include <algorithm>
++#include <ostream>
++
++namespace {
++ bool isOptPrefix( char c ) {
++ return c == '-'
++#ifdef CATCH_PLATFORM_WINDOWS
++ || c == '/'
++#endif
++ ;
++ }
++
++ Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
++ if ( optName[0] == '-'
++#if defined(CATCH_PLATFORM_WINDOWS)
++ || optName[0] == '/'
++#endif
++ ) {
++ return optName.substr( 1, optName.size() );
++ }
++
++ return optName;
++ }
++
++ static size_t find_first_separator(Catch::StringRef sr) {
++ auto is_separator = []( char c ) {
++ return c == ' ' || c == ':' || c == '=';
++ };
++ size_t pos = 0;
++ while (pos < sr.size()) {
++ if (is_separator(sr[pos])) { return pos; }
++ ++pos;
++ }
++
++ return Catch::StringRef::npos;
++ }
++
++} // namespace
++
++namespace Catch {
++ namespace Clara {
++ namespace Detail {
++
++ void TokenStream::loadBuffer() {
++ m_tokenBuffer.clear();
++
++ // Skip any empty strings
++ while ( it != itEnd && it->empty() ) {
++ ++it;
++ }
++
++ if ( it != itEnd ) {
++ StringRef next = *it;
++ if ( isOptPrefix( next[0] ) ) {
++ auto delimiterPos = find_first_separator(next);
++ if ( delimiterPos != StringRef::npos ) {
++ m_tokenBuffer.push_back(
++ { TokenType::Option,
++ next.substr( 0, delimiterPos ) } );
++ m_tokenBuffer.push_back(
++ { TokenType::Argument,
++ next.substr( delimiterPos + 1, next.size() ) } );
++ } else {
++ if ( next[1] != '-' && next.size() > 2 ) {
++ // Combined short args, e.g. "-ab" for "-a -b"
++ for ( size_t i = 1; i < next.size(); ++i ) {
++ m_tokenBuffer.push_back(
++ { TokenType::Option,
++ next.substr( i, 1 ) } );
++ }
++ } else {
++ m_tokenBuffer.push_back(
++ { TokenType::Option, next } );
++ }
++ }
++ } else {
++ m_tokenBuffer.push_back(
++ { TokenType::Argument, next } );
++ }
++ }
++ }
++
++ TokenStream::TokenStream( Args const& args ):
++ TokenStream( args.m_args.begin(), args.m_args.end() ) {}
++
++ TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
++ it( it_ ), itEnd( itEnd_ ) {
++ loadBuffer();
++ }
++
++ TokenStream& TokenStream::operator++() {
++ if ( m_tokenBuffer.size() >= 2 ) {
++ m_tokenBuffer.erase( m_tokenBuffer.begin() );
++ } else {
++ if ( it != itEnd )
++ ++it;
++ loadBuffer();
++ }
++ return *this;
++ }
++
++ ParserResult convertInto( std::string const& source,
++ std::string& target ) {
++ target = source;
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++
++ ParserResult convertInto( std::string const& source,
++ bool& target ) {
++ std::string srcLC = toLower( source );
++
++ if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
++ srcLC == "yes" || srcLC == "on" ) {
++ target = true;
++ } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
++ srcLC == "no" || srcLC == "off" ) {
++ target = false;
++ } else {
++ return ParserResult::runtimeError(
++ "Expected a boolean value but did not recognise: '" +
++ source + '\'' );
++ }
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++
++ size_t ParserBase::cardinality() const { return 1; }
++
++ InternalParseResult ParserBase::parse( Args const& args ) const {
++ return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
++ }
++
++ ParseState::ParseState( ParseResultType type,
++ TokenStream remainingTokens ):
++ m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
++
++ ParserResult BoundFlagRef::setFlag( bool flag ) {
++ m_ref = flag;
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++
++ ResultBase::~ResultBase() = default;
++
++ bool BoundRef::isContainer() const { return false; }
++
++ bool BoundRef::isFlag() const { return false; }
++
++ bool BoundFlagRefBase::isFlag() const { return true; }
++
++} // namespace Detail
++
++ Detail::InternalParseResult Arg::parse(std::string const&,
++ Detail::TokenStream tokens) const {
++ auto validationResult = validate();
++ if (!validationResult)
++ return Detail::InternalParseResult(validationResult);
++
++ auto token = *tokens;
++ if (token.type != Detail::TokenType::Argument)
++ return Detail::InternalParseResult::ok(Detail::ParseState(
++ ParseResultType::NoMatch, CATCH_MOVE(tokens)));
++
++ assert(!m_ref->isFlag());
++ auto valueRef =
++ static_cast<Detail::BoundValueRefBase*>(m_ref.get());
++
++ auto result = valueRef->setValue(static_cast<std::string>(token.token));
++ if ( !result )
++ return Detail::InternalParseResult( result );
++ else
++ return Detail::InternalParseResult::ok(
++ Detail::ParseState( ParseResultType::Matched,
++ CATCH_MOVE( ++tokens ) ) );
++ }
++
++ Opt::Opt(bool& ref) :
++ ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
++
++ Detail::HelpColumns Opt::getHelpColumns() const {
++ ReusableStringStream oss;
++ bool first = true;
++ for (auto const& opt : m_optNames) {
++ if (first)
++ first = false;
++ else
++ oss << ", ";
++ oss << opt;
++ }
++ if (!m_hint.empty())
++ oss << " <" << m_hint << '>';
++ return { oss.str(), m_description };
++ }
++
++ bool Opt::isMatch(StringRef optToken) const {
++ auto normalisedToken = normaliseOpt(optToken);
++ for (auto const& name : m_optNames) {
++ if (normaliseOpt(name) == normalisedToken)
++ return true;
++ }
++ return false;
++ }
++
++ Detail::InternalParseResult Opt::parse(std::string const&,
++ Detail::TokenStream tokens) const {
++ auto validationResult = validate();
++ if (!validationResult)
++ return Detail::InternalParseResult(validationResult);
++
++ if (tokens &&
++ tokens->type == Detail::TokenType::Option) {
++ auto const& token = *tokens;
++ if (isMatch(token.token)) {
++ if (m_ref->isFlag()) {
++ auto flagRef =
++ static_cast<Detail::BoundFlagRefBase*>(
++ m_ref.get());
++ auto result = flagRef->setFlag(true);
++ if (!result)
++ return Detail::InternalParseResult(result);
++ if (result.value() ==
++ ParseResultType::ShortCircuitAll)
++ return Detail::InternalParseResult::ok(Detail::ParseState(
++ result.value(), CATCH_MOVE(tokens)));
++ } else {
++ auto valueRef =
++ static_cast<Detail::BoundValueRefBase*>(
++ m_ref.get());
++ ++tokens;
++ if (!tokens)
++ return Detail::InternalParseResult::runtimeError(
++ "Expected argument following " +
++ token.token);
++ auto const& argToken = *tokens;
++ if (argToken.type != Detail::TokenType::Argument)
++ return Detail::InternalParseResult::runtimeError(
++ "Expected argument following " +
++ token.token);
++ const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
++ if (!result)
++ return Detail::InternalParseResult(result);
++ if (result.value() ==
++ ParseResultType::ShortCircuitAll)
++ return Detail::InternalParseResult::ok(Detail::ParseState(
++ result.value(), CATCH_MOVE(tokens)));
++ }
++ return Detail::InternalParseResult::ok(Detail::ParseState(
++ ParseResultType::Matched, CATCH_MOVE(++tokens)));
++ }
++ }
++ return Detail::InternalParseResult::ok(
++ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
++ }
++
++ Detail::Result Opt::validate() const {
++ if (m_optNames.empty())
++ return Detail::Result::logicError("No options supplied to Opt");
++ for (auto const& name : m_optNames) {
++ if (name.empty())
++ return Detail::Result::logicError(
++ "Option name cannot be empty");
++#ifdef CATCH_PLATFORM_WINDOWS
++ if (name[0] != '-' && name[0] != '/')
++ return Detail::Result::logicError(
++ "Option name must begin with '-' or '/'");
++#else
++ if (name[0] != '-')
++ return Detail::Result::logicError(
++ "Option name must begin with '-'");
++#endif
++ }
++ return ParserRefImpl::validate();
++ }
++
++ ExeName::ExeName() :
++ m_name(std::make_shared<std::string>("<executable>")) {}
++
++ ExeName::ExeName(std::string& ref) : ExeName() {
++ m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
++ }
++
++ Detail::InternalParseResult
++ ExeName::parse(std::string const&,
++ Detail::TokenStream tokens) const {
++ return Detail::InternalParseResult::ok(
++ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
++ }
++
++ ParserResult ExeName::set(std::string const& newName) {
++ auto lastSlash = newName.find_last_of("\\/");
++ auto filename = (lastSlash == std::string::npos)
++ ? newName
++ : newName.substr(lastSlash + 1);
++
++ *m_name = filename;
++ if (m_ref)
++ return m_ref->setValue(filename);
++ else
++ return ParserResult::ok(ParseResultType::Matched);
++ }
++
++
++
++
++ Parser& Parser::operator|=( Parser const& other ) {
++ m_options.insert( m_options.end(),
++ other.m_options.begin(),
++ other.m_options.end() );
++ m_args.insert(
++ m_args.end(), other.m_args.begin(), other.m_args.end() );
++ return *this;
++ }
++
++ std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
++ std::vector<Detail::HelpColumns> cols;
++ cols.reserve( m_options.size() );
++ for ( auto const& o : m_options ) {
++ cols.push_back(o.getHelpColumns());
++ }
++ return cols;
++ }
++
++ void Parser::writeToStream( std::ostream& os ) const {
++ if ( !m_exeName.name().empty() ) {
++ os << "usage:\n"
++ << " " << m_exeName.name() << ' ';
++ bool required = true, first = true;
++ for ( auto const& arg : m_args ) {
++ if ( first )
++ first = false;
++ else
++ os << ' ';
++ if ( arg.isOptional() && required ) {
++ os << '[';
++ required = false;
++ }
++ os << '<' << arg.hint() << '>';
++ if ( arg.cardinality() == 0 )
++ os << " ... ";
++ }
++ if ( !required )
++ os << ']';
++ if ( !m_options.empty() )
++ os << " options";
++ os << "\n\nwhere options are:\n";
++ }
++
++ auto rows = getHelpColumns();
++ size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
++ size_t optWidth = 0;
++ for ( auto const& cols : rows )
++ optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
++
++ optWidth = ( std::min )( optWidth, consoleWidth / 2 );
++
++ for ( auto& cols : rows ) {
++ auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
++ .width( optWidth )
++ .indent( 2 ) +
++ TextFlow::Spacer( 4 ) +
++ TextFlow::Column( static_cast<std::string>(cols.descriptions) )
++ .width( consoleWidth - 7 - optWidth );
++ os << row << '\n';
++ }
++ }
++
++ Detail::Result Parser::validate() const {
++ for ( auto const& opt : m_options ) {
++ auto result = opt.validate();
++ if ( !result )
++ return result;
++ }
++ for ( auto const& arg : m_args ) {
++ auto result = arg.validate();
++ if ( !result )
++ return result;
++ }
++ return Detail::Result::ok();
++ }
++
++ Detail::InternalParseResult
++ Parser::parse( std::string const& exeName,
++ Detail::TokenStream tokens ) const {
++
++ struct ParserInfo {
++ ParserBase const* parser = nullptr;
++ size_t count = 0;
++ };
++ std::vector<ParserInfo> parseInfos;
++ parseInfos.reserve( m_options.size() + m_args.size() );
++ for ( auto const& opt : m_options ) {
++ parseInfos.push_back( { &opt, 0 } );
++ }
++ for ( auto const& arg : m_args ) {
++ parseInfos.push_back( { &arg, 0 } );
++ }
++
++ m_exeName.set( exeName );
++
++ auto result = Detail::InternalParseResult::ok(
++ Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
++ while ( result.value().remainingTokens() ) {
++ bool tokenParsed = false;
++
++ for ( auto& parseInfo : parseInfos ) {
++ if ( parseInfo.parser->cardinality() == 0 ||
++ parseInfo.count < parseInfo.parser->cardinality() ) {
++ result = parseInfo.parser->parse(
++ exeName, CATCH_MOVE(result).value().remainingTokens() );
++ if ( !result )
++ return result;
++ if ( result.value().type() !=
++ ParseResultType::NoMatch ) {
++ tokenParsed = true;
++ ++parseInfo.count;
++ break;
++ }
++ }
++ }
++
++ if ( result.value().type() == ParseResultType::ShortCircuitAll )
++ return result;
++ if ( !tokenParsed )
++ return Detail::InternalParseResult::runtimeError(
++ "Unrecognised token: " +
++ result.value().remainingTokens()->token );
++ }
++ // !TBD Check missing required options
++ return result;
++ }
++
++ Args::Args(int argc, char const* const* argv) :
++ m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
++
++ Args::Args(std::initializer_list<StringRef> args) :
++ m_exeName(*args.begin()),
++ m_args(args.begin() + 1, args.end()) {}
++
++
++ Help::Help( bool& showHelpFlag ):
++ Opt( [&]( bool flag ) {
++ showHelpFlag = flag;
++ return ParserResult::ok( ParseResultType::ShortCircuitAll );
++ } ) {
++ static_cast<Opt&> ( *this )(
++ "display usage information" )["-?"]["-h"]["--help"]
++ .optional();
++ }
++
++ } // namespace Clara
++} // namespace Catch
++
++
++
++
++#include <fstream>
++#include <string>
++
++namespace Catch {
++
++ Clara::Parser makeCommandLineParser( ConfigData& config ) {
++
++ using namespace Clara;
++
++ auto const setWarning = [&]( std::string const& warning ) {
++ if ( warning == "NoAssertions" ) {
++ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
++ return ParserResult::ok( ParseResultType::Matched );
++ } else if ( warning == "UnmatchedTestSpec" ) {
++ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
++ return ParserResult::ok( ParseResultType::Matched );
++ }
++
++ return ParserResult ::runtimeError(
++ "Unrecognised warning option: '" + warning + '\'' );
++ };
++ auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
++ std::ifstream f( filename.c_str() );
++ if( !f.is_open() )
++ return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
++
++ std::string line;
++ while( std::getline( f, line ) ) {
++ line = trim(line);
++ if( !line.empty() && !startsWith( line, '#' ) ) {
++ if( !startsWith( line, '"' ) )
++ line = '"' + CATCH_MOVE(line) + '"';
++ config.testsOrTags.push_back( line );
++ config.testsOrTags.emplace_back( "," );
++ }
++ }
++ //Remove comma in the end
++ if(!config.testsOrTags.empty())
++ config.testsOrTags.erase( config.testsOrTags.end()-1 );
++
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setTestOrder = [&]( std::string const& order ) {
++ if( startsWith( "declared", order ) )
++ config.runOrder = TestRunOrder::Declared;
++ else if( startsWith( "lexical", order ) )
++ config.runOrder = TestRunOrder::LexicographicallySorted;
++ else if( startsWith( "random", order ) )
++ config.runOrder = TestRunOrder::Randomized;
++ else
++ return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setRngSeed = [&]( std::string const& seed ) {
++ if( seed == "time" ) {
++ config.rngSeed = generateRandomSeed(GenerateFrom::Time);
++ return ParserResult::ok(ParseResultType::Matched);
++ } else if (seed == "random-device") {
++ config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
++ return ParserResult::ok(ParseResultType::Matched);
++ }
++
++ // TODO: ideally we should be parsing uint32_t directly
++ // fix this later when we add new parse overload
++ auto parsedSeed = parseUInt( seed, 0 );
++ if ( !parsedSeed ) {
++ return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
++ }
++ config.rngSeed = *parsedSeed;
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
++ Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
++ if ( !maybeMode ) {
++ return ParserResult::runtimeError(
++ "colour mode must be one of: default, ansi, win32, "
++ "or none. '" +
++ colourMode + "' is not recognised" );
++ }
++ auto mode = *maybeMode;
++ if ( !isColourImplAvailable( mode ) ) {
++ return ParserResult::runtimeError(
++ "colour mode '" + colourMode +
++ "' is not supported in this binary" );
++ }
++ config.defaultColourMode = mode;
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setWaitForKeypress = [&]( std::string const& keypress ) {
++ auto keypressLc = toLower( keypress );
++ if (keypressLc == "never")
++ config.waitForKeypress = WaitForKeypress::Never;
++ else if( keypressLc == "start" )
++ config.waitForKeypress = WaitForKeypress::BeforeStart;
++ else if( keypressLc == "exit" )
++ config.waitForKeypress = WaitForKeypress::BeforeExit;
++ else if( keypressLc == "both" )
++ config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
++ else
++ return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setVerbosity = [&]( std::string const& verbosity ) {
++ auto lcVerbosity = toLower( verbosity );
++ if( lcVerbosity == "quiet" )
++ config.verbosity = Verbosity::Quiet;
++ else if( lcVerbosity == "normal" )
++ config.verbosity = Verbosity::Normal;
++ else if( lcVerbosity == "high" )
++ config.verbosity = Verbosity::High;
++ else
++ return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setReporter = [&]( std::string const& userReporterSpec ) {
++ if ( userReporterSpec.empty() ) {
++ return ParserResult::runtimeError( "Received empty reporter spec." );
++ }
++
++ Optional<ReporterSpec> parsed =
++ parseReporterSpec( userReporterSpec );
++ if ( !parsed ) {
++ return ParserResult::runtimeError(
++ "Could not parse reporter spec '" + userReporterSpec +
++ "'" );
++ }
++
++ auto const& reporterSpec = *parsed;
++
++ auto const& factories =
++ getRegistryHub().getReporterRegistry().getFactories();
++ auto result = factories.find( reporterSpec.name() );
++
++ if ( result == factories.end() ) {
++ return ParserResult::runtimeError(
++ "Unrecognized reporter, '" + reporterSpec.name() +
++ "'. Check available with --list-reporters" );
++ }
++
++
++ const bool hadOutputFile = reporterSpec.outputFile().some();
++ config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
++ // It would be enough to check this only once at the very end, but
++ // there is not a place where we could call this check, so do it
++ // every time it could fail. For valid inputs, this is still called
++ // at most once.
++ if (!hadOutputFile) {
++ int n_reporters_without_file = 0;
++ for (auto const& spec : config.reporterSpecifications) {
++ if (spec.outputFile().none()) {
++ n_reporters_without_file++;
++ }
++ }
++ if (n_reporters_without_file > 1) {
++ return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
++ }
++ }
++
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++ auto const setShardCount = [&]( std::string const& shardCount ) {
++ auto parsedCount = parseUInt( shardCount );
++ if ( !parsedCount ) {
++ return ParserResult::runtimeError(
++ "Could not parse '" + shardCount + "' as shard count" );
++ }
++ if ( *parsedCount == 0 ) {
++ return ParserResult::runtimeError(
++ "Shard count must be positive" );
++ }
++ config.shardCount = *parsedCount;
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++
++ auto const setShardIndex = [&](std::string const& shardIndex) {
++ auto parsedIndex = parseUInt( shardIndex );
++ if ( !parsedIndex ) {
++ return ParserResult::runtimeError(
++ "Could not parse '" + shardIndex + "' as shard index" );
++ }
++ config.shardIndex = *parsedIndex;
++ return ParserResult::ok( ParseResultType::Matched );
++ };
++
++ auto cli
++ = ExeName( config.processName )
++ | Help( config.showHelp )
++ | Opt( config.showSuccessfulTests )
++ ["-s"]["--success"]
++ ( "include successful tests in output" )
++ | Opt( config.shouldDebugBreak )
++ ["-b"]["--break"]
++ ( "break into debugger on failure" )
++ | Opt( config.noThrow )
++ ["-e"]["--nothrow"]
++ ( "skip exception tests" )
++ | Opt( config.showInvisibles )
++ ["-i"]["--invisibles"]
++ ( "show invisibles (tabs, newlines)" )
++ | Opt( config.defaultOutputFilename, "filename" )
++ ["-o"]["--out"]
++ ( "default output filename" )
++ | Opt( accept_many, setReporter, "name[::key=value]*" )
++ ["-r"]["--reporter"]
++ ( "reporter to use (defaults to console)" )
++ | Opt( config.name, "name" )
++ ["-n"]["--name"]
++ ( "suite name" )
++ | Opt( [&]( bool ){ config.abortAfter = 1; } )
++ ["-a"]["--abort"]
++ ( "abort at first failure" )
++ | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
++ ["-x"]["--abortx"]
++ ( "abort after x failures" )
++ | Opt( accept_many, setWarning, "warning name" )
++ ["-w"]["--warn"]
++ ( "enable warnings" )
++ | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
++ ["-d"]["--durations"]
++ ( "show test durations" )
++ | Opt( config.minDuration, "seconds" )
++ ["-D"]["--min-duration"]
++ ( "show test durations for tests taking at least the given number of seconds" )
++ | Opt( loadTestNamesFromFile, "filename" )
++ ["-f"]["--input-file"]
++ ( "load test names to run from a file" )
++ | Opt( config.filenamesAsTags )
++ ["-#"]["--filenames-as-tags"]
++ ( "adds a tag for the filename" )
++ | Opt( config.sectionsToRun, "section name" )
++ ["-c"]["--section"]
++ ( "specify section to run" )
++ | Opt( setVerbosity, "quiet|normal|high" )
++ ["-v"]["--verbosity"]
++ ( "set output verbosity" )
++ | Opt( config.listTests )
++ ["--list-tests"]
++ ( "list all/matching test cases" )
++ | Opt( config.listTags )
++ ["--list-tags"]
++ ( "list all/matching tags" )
++ | Opt( config.listReporters )
++ ["--list-reporters"]
++ ( "list all available reporters" )
++ | Opt( config.listListeners )
++ ["--list-listeners"]
++ ( "list all listeners" )
++ | Opt( setTestOrder, "decl|lex|rand" )
++ ["--order"]
++ ( "test case order (defaults to decl)" )
++ | Opt( setRngSeed, "'time'|'random-device'|number" )
++ ["--rng-seed"]
++ ( "set a specific seed for random numbers" )
++ | Opt( setDefaultColourMode, "ansi|win32|none|default" )
++ ["--colour-mode"]
++ ( "what color mode should be used as default" )
++ | Opt( config.libIdentify )
++ ["--libidentify"]
++ ( "report name and version according to libidentify standard" )
++ | Opt( setWaitForKeypress, "never|start|exit|both" )
++ ["--wait-for-keypress"]
++ ( "waits for a keypress before exiting" )
++ | Opt( config.skipBenchmarks)
++ ["--skip-benchmarks"]
++ ( "disable running benchmarks")
++ | Opt( config.benchmarkSamples, "samples" )
++ ["--benchmark-samples"]
++ ( "number of samples to collect (default: 100)" )
++ | Opt( config.benchmarkResamples, "resamples" )
++ ["--benchmark-resamples"]
++ ( "number of resamples for the bootstrap (default: 100000)" )
++ | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
++ ["--benchmark-confidence-interval"]
++ ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
++ | Opt( config.benchmarkNoAnalysis )
++ ["--benchmark-no-analysis"]
++ ( "perform only measurements; do not perform any analysis" )
++ | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
++ ["--benchmark-warmup-time"]
++ ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
++ | Opt( setShardCount, "shard count" )
++ ["--shard-count"]
++ ( "split the tests to execute into this many groups" )
++ | Opt( setShardIndex, "shard index" )
++ ["--shard-index"]
++ ( "index of the group of tests to execute (see --shard-count)" )
++ | Opt( config.allowZeroTests )
++ ["--allow-running-no-tests"]
++ ( "Treat 'No tests run' as a success" )
++ | Arg( config.testsOrTags, "test name|pattern|tags" )
++ ( "which test or tests to use" );
++
++ return cli;
++ }
++
++} // end namespace Catch
++
++
++#if defined(__clang__)
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wexit-time-destructors"
++#endif
++
++
++
++#include <cassert>
++#include <ostream>
++#include <utility>
++
++namespace Catch {
++
++ ColourImpl::~ColourImpl() = default;
++
++ ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
++ return ColourGuard(colourCode, this );
++ }
++
++ void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
++ assert( &stream == &m_colourImpl->m_stream->stream() &&
++ "Engaging colour guard for different stream than used by the "
++ "parent colour implementation" );
++ static_cast<void>( stream );
++
++ m_engaged = true;
++ m_colourImpl->use( m_code );
++ }
++
++ ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
++ ColourImpl const* colour ):
++ m_colourImpl( colour ), m_code( code ) {
++ }
++ ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
++ m_colourImpl( rhs.m_colourImpl ),
++ m_code( rhs.m_code ),
++ m_engaged( rhs.m_engaged ) {
++ rhs.m_engaged = false;
++ }
++ ColourImpl::ColourGuard&
++ ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
++ using std::swap;
++ swap( m_colourImpl, rhs.m_colourImpl );
++ swap( m_code, rhs.m_code );
++ swap( m_engaged, rhs.m_engaged );
++
++ return *this;
++ }
++ ColourImpl::ColourGuard::~ColourGuard() {
++ if ( m_engaged ) {
++ m_colourImpl->use( Colour::None );
++ }
++ }
++
++ ColourImpl::ColourGuard&
++ ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
++ engageImpl( stream );
++ return *this;
++ }
++
++ ColourImpl::ColourGuard&&
++ ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
++ engageImpl( stream );
++ return CATCH_MOVE(*this);
++ }
++
++ namespace {
++ //! A do-nothing implementation of colour, used as fallback for unknown
++ //! platforms, and when the user asks to deactivate all colours.
++ class NoColourImpl final : public ColourImpl {
++ public:
++ NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
++
++ private:
++ void use( Colour::Code ) const override {}
++ };
++ } // namespace
++
++
++} // namespace Catch
++
++
++#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
++
++namespace Catch {
++namespace {
++
++ class Win32ColourImpl final : public ColourImpl {
++ public:
++ Win32ColourImpl(IStream* stream):
++ ColourImpl(stream) {
++ CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
++ GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
++ &csbiInfo );
++ originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
++ originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
++ }
++
++ static bool useImplementationForStream(IStream const& stream) {
++ // Win32 text colour APIs can only be used on console streams
++ // We cannot check that the output hasn't been redirected,
++ // so we just check that the original stream is console stream.
++ return stream.isConsole();
++ }
++
++ private:
++ void use( Colour::Code _colourCode ) const override {
++ switch( _colourCode ) {
++ case Colour::None: return setTextAttribute( originalForegroundAttributes );
++ case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
++ case Colour::Red: return setTextAttribute( FOREGROUND_RED );
++ case Colour::Green: return setTextAttribute( FOREGROUND_GREEN );
++ case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE );
++ case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
++ case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
++ case Colour::Grey: return setTextAttribute( 0 );
++
++ case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY );
++ case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
++ case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
++ case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
++ case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
++
++ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
++
++ default:
++ CATCH_ERROR( "Unknown colour requested" );
++ }
++ }
++
++ void setTextAttribute( WORD _textAttribute ) const {
++ SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
++ _textAttribute |
++ originalBackgroundAttributes );
++ }
++ WORD originalForegroundAttributes;
++ WORD originalBackgroundAttributes;
++ };
++
++} // end anon namespace
++} // end namespace Catch
++
++#endif // Windows/ ANSI/ None
++
++
++#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
++# define CATCH_INTERNAL_HAS_ISATTY
++# include <unistd.h>
++#endif
++
++namespace Catch {
++namespace {
++
++ class ANSIColourImpl final : public ColourImpl {
++ public:
++ ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
++
++ static bool useImplementationForStream(IStream const& stream) {
++ // This is kinda messy due to trying to support a bunch of
++ // different platforms at once.
++ // The basic idea is that if we are asked to do autodetection (as
++ // opposed to being told to use posixy colours outright), then we
++ // only want to use the colours if we are writing to console.
++ // However, console might be redirected, so we make an attempt at
++ // checking for that on platforms where we know how to do that.
++ bool useColour = stream.isConsole();
++#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
++ !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
++ ErrnoGuard _; // for isatty
++ useColour = useColour && isatty( STDOUT_FILENO );
++# endif
++# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
++ useColour = useColour && !isDebuggerActive();
++# endif
++
++ return useColour;
++ }
++
++ private:
++ void use( Colour::Code _colourCode ) const override {
++ auto setColour = [&out =
++ m_stream->stream()]( char const* escapeCode ) {
++ // The escape sequence must be flushed to console, otherwise
++ // if stdin and stderr are intermixed, we'd get accidentally
++ // coloured output.
++ out << '\033' << escapeCode << std::flush;
++ };
++ switch( _colourCode ) {
++ case Colour::None:
++ case Colour::White: return setColour( "[0m" );
++ case Colour::Red: return setColour( "[0;31m" );
++ case Colour::Green: return setColour( "[0;32m" );
++ case Colour::Blue: return setColour( "[0;34m" );
++ case Colour::Cyan: return setColour( "[0;36m" );
++ case Colour::Yellow: return setColour( "[0;33m" );
++ case Colour::Grey: return setColour( "[1;30m" );
++
++ case Colour::LightGrey: return setColour( "[0;37m" );
++ case Colour::BrightRed: return setColour( "[1;31m" );
++ case Colour::BrightGreen: return setColour( "[1;32m" );
++ case Colour::BrightWhite: return setColour( "[1;37m" );
++ case Colour::BrightYellow: return setColour( "[1;33m" );
++
++ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
++ default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
++ }
++ }
++ };
++
++} // end anon namespace
++} // end namespace Catch
++
++namespace Catch {
++
++ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
++ IStream* stream ) {
++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
++ if ( colourSelection == ColourMode::Win32 ) {
++ return Detail::make_unique<Win32ColourImpl>( stream );
++ }
++#endif
++ if ( colourSelection == ColourMode::ANSI ) {
++ return Detail::make_unique<ANSIColourImpl>( stream );
++ }
++ if ( colourSelection == ColourMode::None ) {
++ return Detail::make_unique<NoColourImpl>( stream );
++ }
++
++ if ( colourSelection == ColourMode::PlatformDefault) {
++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
++ if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
++ return Detail::make_unique<Win32ColourImpl>( stream );
++ }
++#endif
++ if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
++ return Detail::make_unique<ANSIColourImpl>( stream );
++ }
++ return Detail::make_unique<NoColourImpl>( stream );
++ }
++
++ CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
++ }
++
++ bool isColourImplAvailable( ColourMode colourSelection ) {
++ switch ( colourSelection ) {
++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
++ case ColourMode::Win32:
++#endif
++ case ColourMode::ANSI:
++ case ColourMode::None:
++ case ColourMode::PlatformDefault:
++ return true;
++ default:
++ return false;
++ }
++ }
++
++
++} // end namespace Catch
++
++#if defined(__clang__)
++# pragma clang diagnostic pop
++#endif
++
++
++
++
++namespace Catch {
++
++ Context* Context::currentContext = nullptr;
++
++ void cleanUpContext() {
++ delete Context::currentContext;
++ Context::currentContext = nullptr;
++ }
++ void Context::createContext() {
++ currentContext = new Context();
++ }
++
++ Context& getCurrentMutableContext() {
++ if ( !Context::currentContext ) { Context::createContext(); }
++ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
++ return *Context::currentContext;
++ }
++
++ void Context::setResultCapture( IResultCapture* resultCapture ) {
++ m_resultCapture = resultCapture;
++ }
++
++ void Context::setConfig( IConfig const* config ) { m_config = config; }
++
++ SimplePcg32& sharedRng() {
++ static SimplePcg32 s_rng;
++ return s_rng;
++ }
++
++}
++
++
++
++
++
++#include <ostream>
++
++#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
++#include <android/log.h>
++
++ namespace Catch {
++ void writeToDebugConsole( std::string const& text ) {
++ __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
++ }
++ }
++
++#elif defined(CATCH_PLATFORM_WINDOWS)
++
++ namespace Catch {
++ void writeToDebugConsole( std::string const& text ) {
++ ::OutputDebugStringA( text.c_str() );
++ }
++ }
++
++#else
++
++ namespace Catch {
++ void writeToDebugConsole( std::string const& text ) {
++ // !TBD: Need a version for Mac/ XCode and other IDEs
++ Catch::cout() << text;
++ }
++ }
++
++#endif // Platform
++
++
++
++#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
++
++# include <cassert>
++# include <sys/types.h>
++# include <unistd.h>
++# include <cstddef>
++# include <ostream>
++
++#ifdef __apple_build_version__
++ // These headers will only compile with AppleClang (XCode)
++ // For other compilers (Clang, GCC, ... ) we need to exclude them
++# include <sys/sysctl.h>
++#endif
++
++ namespace Catch {
++ #ifdef __apple_build_version__
++ // The following function is taken directly from the following technical note:
++ // https://developer.apple.com/library/archive/qa/qa1361/_index.html
++
++ // Returns true if the current process is being debugged (either
++ // running under the debugger or has a debugger attached post facto).
++ bool isDebuggerActive(){
++ int mib[4];
++ struct kinfo_proc info;
++ std::size_t size;
++
++ // Initialize the flags so that, if sysctl fails for some bizarre
++ // reason, we get a predictable result.
++
++ info.kp_proc.p_flag = 0;
++
++ // Initialize mib, which tells sysctl the info we want, in this case
++ // we're looking for information about a specific process ID.
++
++ mib[0] = CTL_KERN;
++ mib[1] = KERN_PROC;
++ mib[2] = KERN_PROC_PID;
++ mib[3] = getpid();
++
++ // Call sysctl.
++
++ size = sizeof(info);
++ if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
++ Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
++ return false;
++ }
++
++ // We're being debugged if the P_TRACED flag is set.
++
++ return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
++ }
++ #else
++ bool isDebuggerActive() {
++ // We need to find another way to determine this for non-appleclang compilers on macOS
++ return false;
++ }
++ #endif
++ } // namespace Catch
++
++#elif defined(CATCH_PLATFORM_LINUX)
++ #include <fstream>
++ #include <string>
++
++ namespace Catch{
++ // The standard POSIX way of detecting a debugger is to attempt to
++ // ptrace() the process, but this needs to be done from a child and not
++ // this process itself to still allow attaching to this process later
++ // if wanted, so is rather heavy. Under Linux we have the PID of the
++ // "debugger" (which doesn't need to be gdb, of course, it could also
++ // be strace, for example) in /proc/$PID/status, so just get it from
++ // there instead.
++ bool isDebuggerActive(){
++ // Libstdc++ has a bug, where std::ifstream sets errno to 0
++ // This way our users can properly assert over errno values
++ ErrnoGuard guard;
++ std::ifstream in("/proc/self/status");
++ for( std::string line; std::getline(in, line); ) {
++ static const int PREFIX_LEN = 11;
++ if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
++ // We're traced if the PID is not 0 and no other PID starts
++ // with 0 digit, so it's enough to check for just a single
++ // character.
++ return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
++ }
++ }
++
++ return false;
++ }
++ } // namespace Catch
++#elif defined(_MSC_VER)
++ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
++ namespace Catch {
++ bool isDebuggerActive() {
++ return IsDebuggerPresent() != 0;
++ }
++ }
++#elif defined(__MINGW32__)
++ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
++ namespace Catch {
++ bool isDebuggerActive() {
++ return IsDebuggerPresent() != 0;
++ }
++ }
++#else
++ namespace Catch {
++ bool isDebuggerActive() { return false; }
++ }
++#endif // Platform
++
++
++
++
++namespace Catch {
++
++ void ITransientExpression::streamReconstructedExpression(
++ std::ostream& os ) const {
++ // We can't make this function pure virtual to keep ITransientExpression
++ // constexpr, so we write error message instead
++ os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
++ }
++
++ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
++ if( lhs.size() + rhs.size() < 40 &&
++ lhs.find('\n') == std::string::npos &&
++ rhs.find('\n') == std::string::npos )
++ os << lhs << ' ' << op << ' ' << rhs;
++ else
++ os << lhs << '\n' << op << '\n' << rhs;
++ }
++}
++
++
++
++#include <stdexcept>
++
++
++namespace Catch {
++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
++ [[noreturn]]
++ void throw_exception(std::exception const& e) {
++ Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
++ << "The message was: " << e.what() << '\n';
++ std::terminate();
++ }
++#endif
++
++ [[noreturn]]
++ void throw_logic_error(std::string const& msg) {
++ throw_exception(std::logic_error(msg));
++ }
++
++ [[noreturn]]
++ void throw_domain_error(std::string const& msg) {
++ throw_exception(std::domain_error(msg));
++ }
++
++ [[noreturn]]
++ void throw_runtime_error(std::string const& msg) {
++ throw_exception(std::runtime_error(msg));
++ }
++
++
++
++} // namespace Catch;
++
++
++
++#include <cassert>
++
++namespace Catch {
++
++ IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
++
++ namespace Detail {
++
++ namespace {
++ // Extracts the actual name part of an enum instance
++ // In other words, it returns the Blue part of Bikeshed::Colour::Blue
++ StringRef extractInstanceName(StringRef enumInstance) {
++ // Find last occurrence of ":"
++ size_t name_start = enumInstance.size();
++ while (name_start > 0 && enumInstance[name_start - 1] != ':') {
++ --name_start;
++ }
++ return enumInstance.substr(name_start, enumInstance.size() - name_start);
++ }
++ }
++
++ std::vector<StringRef> parseEnums( StringRef enums ) {
++ auto enumValues = splitStringRef( enums, ',' );
++ std::vector<StringRef> parsed;
++ parsed.reserve( enumValues.size() );
++ for( auto const& enumValue : enumValues ) {
++ parsed.push_back(trim(extractInstanceName(enumValue)));
++ }
++ return parsed;
++ }
++
++ EnumInfo::~EnumInfo() = default;
++
++ StringRef EnumInfo::lookup( int value ) const {
++ for( auto const& valueToName : m_values ) {
++ if( valueToName.first == value )
++ return valueToName.second;
++ }
++ return "{** unexpected enum value **}"_sr;
++ }
++
++ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
++ auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
++ enumInfo->m_name = enumName;
++ enumInfo->m_values.reserve( values.size() );
++
++ const auto valueNames = Catch::Detail::parseEnums( allValueNames );
++ assert( valueNames.size() == values.size() );
++ std::size_t i = 0;
++ for( auto value : values )
++ enumInfo->m_values.emplace_back(value, valueNames[i++]);
++
++ return enumInfo;
++ }
++
++ EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
++ m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
++ return *m_enumInfos.back();
++ }
++
++ } // Detail
++} // Catch
++
++
++
++
++
++#include <cerrno>
++
++namespace Catch {
++ ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
++ ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
++}
++
++
++
++#include <exception>
++
++namespace Catch {
++
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ namespace {
++ static std::string tryTranslators(
++ std::vector<
++ Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
++ if ( translators.empty() ) {
++ std::rethrow_exception( std::current_exception() );
++ } else {
++ return translators[0]->translate( translators.begin() + 1,
++ translators.end() );
++ }
++ }
++
++ }
++#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++
++ ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
++
++ void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
++ m_translators.push_back( CATCH_MOVE( translator ) );
++ }
++
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ std::string ExceptionTranslatorRegistry::translateActiveException() const {
++ // Compiling a mixed mode project with MSVC means that CLR
++ // exceptions will be caught in (...) as well. However, these do
++ // do not fill-in std::current_exception and thus lead to crash
++ // when attempting rethrow.
++ // /EHa switch also causes structured exceptions to be caught
++ // here, but they fill-in current_exception properly, so
++ // at worst the output should be a little weird, instead of
++ // causing a crash.
++ if ( std::current_exception() == nullptr ) {
++ return "Non C++ exception. Possibly a CLR exception.";
++ }
++
++ // First we try user-registered translators. If none of them can
++ // handle the exception, it will be rethrown handled by our defaults.
++ try {
++ return tryTranslators(m_translators);
++ }
++ // To avoid having to handle TFE explicitly everywhere, we just
++ // rethrow it so that it goes back up the caller.
++ catch( TestFailureException& ) {
++ std::rethrow_exception(std::current_exception());
++ }
++ catch( TestSkipException& ) {
++ std::rethrow_exception(std::current_exception());
++ }
++ catch( std::exception const& ex ) {
++ return ex.what();
++ }
++ catch( std::string const& msg ) {
++ return msg;
++ }
++ catch( const char* msg ) {
++ return msg;
++ }
++ catch(...) {
++ return "Unknown exception";
++ }
++ }
++
++#else // ^^ Exceptions are enabled // Exceptions are disabled vv
++ std::string ExceptionTranslatorRegistry::translateActiveException() const {
++ CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
++ }
++#endif
++
++}
++
++
++
++/** \file
++ * This file provides platform specific implementations of FatalConditionHandler
++ *
++ * This means that there is a lot of conditional compilation, and platform
++ * specific code. Currently, Catch2 supports a dummy handler (if no
++ * handler is desired), and 2 platform specific handlers:
++ * * Windows' SEH
++ * * POSIX signals
++ *
++ * Consequently, various pieces of code below are compiled if either of
++ * the platform specific handlers is enabled, or if none of them are
++ * enabled. It is assumed that both cannot be enabled at the same time,
++ * and doing so should cause a compilation error.
++ *
++ * If another platform specific handler is added, the compile guards
++ * below will need to be updated taking these assumptions into account.
++ */
++
++
++
++#include <algorithm>
++
++#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
++
++namespace Catch {
++
++ // If neither SEH nor signal handling is required, the handler impls
++ // do not have to do anything, and can be empty.
++ void FatalConditionHandler::engage_platform() {}
++ void FatalConditionHandler::disengage_platform() noexcept {}
++ FatalConditionHandler::FatalConditionHandler() = default;
++ FatalConditionHandler::~FatalConditionHandler() = default;
++
++} // end namespace Catch
++
++#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
++
++#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
++#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
++#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
++
++#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
++
++namespace {
++ //! Signals fatal error message to the run context
++ void reportFatal( char const * const message ) {
++ Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
++ }
++
++ //! Minimal size Catch2 needs for its own fatal error handling.
++ //! Picked empirically, so it might not be sufficient on all
++ //! platforms, and for all configurations.
++ constexpr std::size_t minStackSizeForErrors = 32 * 1024;
++} // end unnamed namespace
++
++#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
++
++#if defined( CATCH_CONFIG_WINDOWS_SEH )
++
++namespace Catch {
++
++ struct SignalDefs { DWORD id; const char* name; };
++
++ // There is no 1-1 mapping between signals and windows exceptions.
++ // Windows can easily distinguish between SO and SigSegV,
++ // but SigInt, SigTerm, etc are handled differently.
++ static SignalDefs signalDefs[] = {
++ { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" },
++ { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
++ { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
++ { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
++ };
++
++ static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
++ for (auto const& def : signalDefs) {
++ if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
++ reportFatal(def.name);
++ }
++ }
++ // If its not an exception we care about, pass it along.
++ // This stops us from eating debugger breaks etc.
++ return EXCEPTION_CONTINUE_SEARCH;
++ }
++
++ // Since we do not support multiple instantiations, we put these
++ // into global variables and rely on cleaning them up in outlined
++ // constructors/destructors
++ static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
++
++
++ // For MSVC, we reserve part of the stack memory for handling
++ // memory overflow structured exception.
++ FatalConditionHandler::FatalConditionHandler() {
++ ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
++ if (!SetThreadStackGuarantee(&guaranteeSize)) {
++ // We do not want to fully error out, because needing
++ // the stack reserve should be rare enough anyway.
++ Catch::cerr()
++ << "Failed to reserve piece of stack."
++ << " Stack overflows will not be reported successfully.";
++ }
++ }
++
++ // We do not attempt to unset the stack guarantee, because
++ // Windows does not support lowering the stack size guarantee.
++ FatalConditionHandler::~FatalConditionHandler() = default;
++
++
++ void FatalConditionHandler::engage_platform() {
++ // Register as a the top level exception filter.
++ previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
++ }
++
++ void FatalConditionHandler::disengage_platform() noexcept {
++ if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
++ Catch::cerr()
++ << "Unexpected SEH unhandled exception filter on disengage."
++ << " The filter was restored, but might be rolled back unexpectedly.";
++ }
++ previousTopLevelExceptionFilter = nullptr;
++ }
++
++} // end namespace Catch
++
++#endif // CATCH_CONFIG_WINDOWS_SEH
++
++#if defined( CATCH_CONFIG_POSIX_SIGNALS )
++
++#include <signal.h>
++
++namespace Catch {
++
++ struct SignalDefs {
++ int id;
++ const char* name;
++ };
++
++ static SignalDefs signalDefs[] = {
++ { SIGINT, "SIGINT - Terminal interrupt signal" },
++ { SIGILL, "SIGILL - Illegal instruction signal" },
++ { SIGFPE, "SIGFPE - Floating point error signal" },
++ { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
++ { SIGTERM, "SIGTERM - Termination request signal" },
++ { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
++ };
++
++// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
++// which is zero initialization, but not explicit. We want to avoid
++// that.
++#if defined(__GNUC__)
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
++#endif
++
++ static char* altStackMem = nullptr;
++ static std::size_t altStackSize = 0;
++ static stack_t oldSigStack{};
++ static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
++
++ static void restorePreviousSignalHandlers() noexcept {
++ // We set signal handlers back to the previous ones. Hopefully
++ // nobody overwrote them in the meantime, and doesn't expect
++ // their signal handlers to live past ours given that they
++ // installed them after ours..
++ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
++ sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
++ }
++ // Return the old stack
++ sigaltstack(&oldSigStack, nullptr);
++ }
++
++ static void handleSignal( int sig ) {
++ char const * name = "<unknown signal>";
++ for (auto const& def : signalDefs) {
++ if (sig == def.id) {
++ name = def.name;
++ break;
++ }
++ }
++ // We need to restore previous signal handlers and let them do
++ // their thing, so that the users can have the debugger break
++ // when a signal is raised, and so on.
++ restorePreviousSignalHandlers();
++ reportFatal( name );
++ raise( sig );
++ }
++
++ FatalConditionHandler::FatalConditionHandler() {
++ assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
++ if (altStackSize == 0) {
++ altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
++ }
++ altStackMem = new char[altStackSize]();
++ }
++
++ FatalConditionHandler::~FatalConditionHandler() {
++ delete[] altStackMem;
++ // We signal that another instance can be constructed by zeroing
++ // out the pointer.
++ altStackMem = nullptr;
++ }
++
++ void FatalConditionHandler::engage_platform() {
++ stack_t sigStack;
++ sigStack.ss_sp = altStackMem;
++ sigStack.ss_size = altStackSize;
++ sigStack.ss_flags = 0;
++ sigaltstack(&sigStack, &oldSigStack);
++ struct sigaction sa = { };
++
++ sa.sa_handler = handleSignal;
++ sa.sa_flags = SA_ONSTACK;
++ for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
++ sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
++ }
++ }
++
++#if defined(__GNUC__)
++# pragma GCC diagnostic pop
++#endif
++
++
++ void FatalConditionHandler::disengage_platform() noexcept {
++ restorePreviousSignalHandlers();
++ }
++
++} // end namespace Catch
++
++#endif // CATCH_CONFIG_POSIX_SIGNALS
++
++
++
++
++#include <cstring>
++
++namespace Catch {
++ namespace Detail {
++
++ uint32_t convertToBits(float f) {
++ static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
++ uint32_t i;
++ std::memcpy(&i, &f, sizeof(f));
++ return i;
++ }
++
++ uint64_t convertToBits(double d) {
++ static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
++ uint64_t i;
++ std::memcpy(&i, &d, sizeof(d));
++ return i;
++ }
++
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wfloat-equal"
++#endif
++ bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
++ bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
++#if defined( __GNUC__ ) || defined( __clang__ )
++# pragma GCC diagnostic pop
++#endif
++
++
++ } // end namespace Detail
++} // end namespace Catch
++
++
++
++
++
++
++#include <cstdlib>
++
++namespace Catch {
++ namespace Detail {
++
++#if !defined (CATCH_CONFIG_GETENV)
++ char const* getEnv( char const* ) { return nullptr; }
++#else
++
++ char const* getEnv( char const* varName ) {
++# if defined( _MSC_VER )
++# pragma warning( push )
++# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
++# endif
++
++ return std::getenv( varName );
++
++# if defined( _MSC_VER )
++# pragma warning( pop )
++# endif
++ }
++#endif
++} // namespace Detail
++} // namespace Catch
++
++
++
++
++#include <cstdio>
++#include <fstream>
++#include <sstream>
++#include <vector>
++
++namespace Catch {
++
++ Catch::IStream::~IStream() = default;
++
++namespace Detail {
++ namespace {
++ template<typename WriterF, std::size_t bufferSize=256>
++ class StreamBufImpl final : public std::streambuf {
++ char data[bufferSize];
++ WriterF m_writer;
++
++ public:
++ StreamBufImpl() {
++ setp( data, data + sizeof(data) );
++ }
++
++ ~StreamBufImpl() noexcept override {
++ StreamBufImpl::sync();
++ }
++
++ private:
++ int overflow( int c ) override {
++ sync();
++
++ if( c != EOF ) {
++ if( pbase() == epptr() )
++ m_writer( std::string( 1, static_cast<char>( c ) ) );
++ else
++ sputc( static_cast<char>( c ) );
++ }
++ return 0;
++ }
++
++ int sync() override {
++ if( pbase() != pptr() ) {
++ m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
++ setp( pbase(), epptr() );
++ }
++ return 0;
++ }
++ };
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ struct OutputDebugWriter {
++
++ void operator()( std::string const& str ) {
++ if ( !str.empty() ) {
++ writeToDebugConsole( str );
++ }
++ }
++ };
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ class FileStream final : public IStream {
++ std::ofstream m_ofs;
++ public:
++ FileStream( std::string const& filename ) {
++ m_ofs.open( filename.c_str() );
++ CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
++ m_ofs << std::unitbuf;
++ }
++ public: // IStream
++ std::ostream& stream() override {
++ return m_ofs;
++ }
++ };
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ class CoutStream final : public IStream {
++ std::ostream m_os;
++ public:
++ // Store the streambuf from cout up-front because
++ // cout may get redirected when running tests
++ CoutStream() : m_os( Catch::cout().rdbuf() ) {}
++
++ public: // IStream
++ std::ostream& stream() override { return m_os; }
++ bool isConsole() const override { return true; }
++ };
++
++ class CerrStream : public IStream {
++ std::ostream m_os;
++
++ public:
++ // Store the streambuf from cerr up-front because
++ // cout may get redirected when running tests
++ CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
++
++ public: // IStream
++ std::ostream& stream() override { return m_os; }
++ bool isConsole() const override { return true; }
++ };
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ class DebugOutStream final : public IStream {
++ Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
++ std::ostream m_os;
++ public:
++ DebugOutStream()
++ : m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
++ m_os( m_streamBuf.get() )
++ {}
++
++ public: // IStream
++ std::ostream& stream() override { return m_os; }
++ };
++
++ } // unnamed namespace
++} // namespace Detail
++
++ ///////////////////////////////////////////////////////////////////////////
++
++ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
++ if ( filename.empty() || filename == "-" ) {
++ return Detail::make_unique<Detail::CoutStream>();
++ }
++ if( filename[0] == '%' ) {
++ if ( filename == "%debug" ) {
++ return Detail::make_unique<Detail::DebugOutStream>();
++ } else if ( filename == "%stderr" ) {
++ return Detail::make_unique<Detail::CerrStream>();
++ } else if ( filename == "%stdout" ) {
++ return Detail::make_unique<Detail::CoutStream>();
++ } else {
++ CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
++ }
++ }
++ return Detail::make_unique<Detail::FileStream>( filename );
++ }
++
++}
++
++
++
++namespace Catch {
++ void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
++ for ( std::uint64_t i = 0; i < level; ++i ) {
++ os << " ";
++ }
++ }
++ void JsonUtils::appendCommaNewline( std::ostream& os,
++ bool& should_comma,
++ std::uint64_t level ) {
++ if ( should_comma ) { os << ','; }
++ should_comma = true;
++ os << '\n';
++ indent( os, level );
++ }
++
++ JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
++ JsonObjectWriter{ os, 0 } {}
++
++ JsonObjectWriter::JsonObjectWriter( std::ostream& os,
++ std::uint64_t indent_level ):
++ m_os{ os }, m_indent_level{ indent_level } {
++ m_os << '{';
++ }
++ JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
++ m_os{ source.m_os },
++ m_indent_level{ source.m_indent_level },
++ m_should_comma{ source.m_should_comma },
++ m_active{ source.m_active } {
++ source.m_active = false;
++ }
++
++ JsonObjectWriter::~JsonObjectWriter() {
++ if ( !m_active ) { return; }
++
++ m_os << '\n';
++ JsonUtils::indent( m_os, m_indent_level );
++ m_os << '}';
++ }
++
++ JsonValueWriter JsonObjectWriter::write( StringRef key ) {
++ JsonUtils::appendCommaNewline(
++ m_os, m_should_comma, m_indent_level + 1 );
++
++ m_os << '"' << key << "\": ";
++ return JsonValueWriter{ m_os, m_indent_level + 1 };
++ }
++
++ JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
++ JsonArrayWriter{ os, 0 } {}
++ JsonArrayWriter::JsonArrayWriter( std::ostream& os,
++ std::uint64_t indent_level ):
++ m_os{ os }, m_indent_level{ indent_level } {
++ m_os << '[';
++ }
++ JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
++ m_os{ source.m_os },
++ m_indent_level{ source.m_indent_level },
++ m_should_comma{ source.m_should_comma },
++ m_active{ source.m_active } {
++ source.m_active = false;
++ }
++ JsonArrayWriter::~JsonArrayWriter() {
++ if ( !m_active ) { return; }
++
++ m_os << '\n';
++ JsonUtils::indent( m_os, m_indent_level );
++ m_os << ']';
++ }
++
++ JsonObjectWriter JsonArrayWriter::writeObject() {
++ JsonUtils::appendCommaNewline(
++ m_os, m_should_comma, m_indent_level + 1 );
++ return JsonObjectWriter{ m_os, m_indent_level + 1 };
++ }
++
++ JsonArrayWriter JsonArrayWriter::writeArray() {
++ JsonUtils::appendCommaNewline(
++ m_os, m_should_comma, m_indent_level + 1 );
++ return JsonArrayWriter{ m_os, m_indent_level + 1 };
++ }
++
++ JsonArrayWriter& JsonArrayWriter::write( bool value ) {
++ return writeImpl( value );
++ }
++
++ JsonValueWriter::JsonValueWriter( std::ostream& os ):
++ JsonValueWriter{ os, 0 } {}
++
++ JsonValueWriter::JsonValueWriter( std::ostream& os,
++ std::uint64_t indent_level ):
++ m_os{ os }, m_indent_level{ indent_level } {}
++
++ JsonObjectWriter JsonValueWriter::writeObject() && {
++ return JsonObjectWriter{ m_os, m_indent_level };
++ }
++
++ JsonArrayWriter JsonValueWriter::writeArray() && {
++ return JsonArrayWriter{ m_os, m_indent_level };
++ }
++
++ void JsonValueWriter::write( Catch::StringRef value ) && {
++ writeImpl( value, true );
++ }
++
++ void JsonValueWriter::write( bool value ) && {
++ writeImpl( value ? "true"_sr : "false"_sr, false );
++ }
++
++ void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
++ if ( quote ) { m_os << '"'; }
++ for (char c : value) {
++ // Escape list taken from https://www.json.org/json-en.html,
++ // string definition.
++ // Note that while forward slash _can_ be escaped, it does
++ // not have to be, if JSON is not further embedded somewhere
++ // where forward slash is meaningful.
++ if ( c == '"' ) {
++ m_os << "\\\"";
++ } else if ( c == '\\' ) {
++ m_os << "\\\\";
++ } else if ( c == '\b' ) {
++ m_os << "\\b";
++ } else if ( c == '\f' ) {
++ m_os << "\\f";
++ } else if ( c == '\n' ) {
++ m_os << "\\n";
++ } else if ( c == '\r' ) {
++ m_os << "\\r";
++ } else if ( c == '\t' ) {
++ m_os << "\\t";
++ } else {
++ m_os << c;
++ }
++ }
++ if ( quote ) { m_os << '"'; }
++ }
++
++} // namespace Catch
++
++
++
++
++namespace Catch {
++
++ auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
++ if (lazyExpr.m_isNegated)
++ os << '!';
++
++ if (lazyExpr) {
++ if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
++ os << '(' << *lazyExpr.m_transientExpression << ')';
++ else
++ os << *lazyExpr.m_transientExpression;
++ } else {
++ os << "{** error - unchecked empty expression requested **}";
++ }
++ return os;
++ }
++
++} // namespace Catch
++
++
++
++
++#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
++#include <crtdbg.h>
++
++namespace Catch {
++
++ LeakDetector::LeakDetector() {
++ int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
++ flag |= _CRTDBG_LEAK_CHECK_DF;
++ flag |= _CRTDBG_ALLOC_MEM_DF;
++ _CrtSetDbgFlag(flag);
++ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
++ _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
++ // Change this to leaking allocation's number to break there
++ _CrtSetBreakAlloc(-1);
++ }
++}
++
++#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
++
++ Catch::LeakDetector::LeakDetector() = default;
++
++#endif // CATCH_CONFIG_WINDOWS_CRTDBG
++
++Catch::LeakDetector::~LeakDetector() {
++ Catch::cleanUp();
++}
++
++
++
++
++namespace Catch {
++ namespace {
++
++ void listTests(IEventListener& reporter, IConfig const& config) {
++ auto const& testSpec = config.testSpec();
++ auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
++ reporter.listTests(matchedTestCases);
++ }
++
++ void listTags(IEventListener& reporter, IConfig const& config) {
++ auto const& testSpec = config.testSpec();
++ std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
++
++ std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
++ for (auto const& testCase : matchedTestCases) {
++ for (auto const& tagName : testCase.getTestCaseInfo().tags) {
++ auto it = tagCounts.find(tagName.original);
++ if (it == tagCounts.end())
++ it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
++ it->second.add(tagName.original);
++ }
++ }
++
++ std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
++ for (auto& tagc : tagCounts) {
++ infos.push_back(CATCH_MOVE(tagc.second));
++ }
++
++ reporter.listTags(infos);
++ }
++
++ void listReporters(IEventListener& reporter) {
++ std::vector<ReporterDescription> descriptions;
++
++ auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
++ descriptions.reserve(factories.size());
++ for (auto const& fac : factories) {
++ descriptions.push_back({ fac.first, fac.second->getDescription() });
++ }
++
++ reporter.listReporters(descriptions);
++ }
++
++ void listListeners(IEventListener& reporter) {
++ std::vector<ListenerDescription> descriptions;
++
++ auto const& factories =
++ getRegistryHub().getReporterRegistry().getListeners();
++ descriptions.reserve( factories.size() );
++ for ( auto const& fac : factories ) {
++ descriptions.push_back( { fac->getName(), fac->getDescription() } );
++ }
++
++ reporter.listListeners( descriptions );
++ }
++
++ } // end anonymous namespace
++
++ void TagInfo::add( StringRef spelling ) {
++ ++count;
++ spellings.insert( spelling );
++ }
++
++ std::string TagInfo::all() const {
++ // 2 per tag for brackets '[' and ']'
++ size_t size = spellings.size() * 2;
++ for (auto const& spelling : spellings) {
++ size += spelling.size();
++ }
++
++ std::string out; out.reserve(size);
++ for (auto const& spelling : spellings) {
++ out += '[';
++ out += spelling;
++ out += ']';
++ }
++ return out;
++ }
++
++ bool list( IEventListener& reporter, Config const& config ) {
++ bool listed = false;
++ if (config.listTests()) {
++ listed = true;
++ listTests(reporter, config);
++ }
++ if (config.listTags()) {
++ listed = true;
++ listTags(reporter, config);
++ }
++ if (config.listReporters()) {
++ listed = true;
++ listReporters(reporter);
++ }
++ if ( config.listListeners() ) {
++ listed = true;
++ listListeners( reporter );
++ }
++ return listed;
++ }
++
++} // end namespace Catch
++
++
++
++namespace Catch {
++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
++ static LeakDetector leakDetector;
++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
++}
++
++// Allow users of amalgamated .cpp file to remove our main and provide their own.
++#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
++
++#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
++// Standard C/C++ Win32 Unicode wmain entry point
++extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
++#else
++// Standard C/C++ main entry point
++int main (int argc, char * argv[]) {
++#endif
++
++ // We want to force the linker not to discard the global variable
++ // and its constructor, as it (optionally) registers leak detector
++ (void)&Catch::leakDetector;
++
++ return Catch::Session().run( argc, argv );
++}
++
++#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
++
++
++
++
++namespace Catch {
++
++ MessageInfo::MessageInfo( StringRef _macroName,
++ SourceLineInfo const& _lineInfo,
++ ResultWas::OfType _type )
++ : macroName( _macroName ),
++ lineInfo( _lineInfo ),
++ type( _type ),
++ sequence( ++globalCount )
++ {}
++
++ // This may need protecting if threading support is added
++ unsigned int MessageInfo::globalCount = 0;
++
++} // end namespace Catch
++
++
++
++#include <cstdio>
++#include <cstring>
++#include <sstream>
++
++#if defined(CATCH_CONFIG_NEW_CAPTURE)
++ #if defined(_MSC_VER)
++ #include <io.h> //_dup and _dup2
++ #define dup _dup
++ #define dup2 _dup2
++ #define fileno _fileno
++ #else
++ #include <unistd.h> // dup and dup2
++ #endif
++#endif
++
++
++namespace Catch {
++
++ RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
++ : m_originalStream( originalStream ),
++ m_redirectionStream( redirectionStream ),
++ m_prevBuf( m_originalStream.rdbuf() )
++ {
++ m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
++ }
++
++ RedirectedStream::~RedirectedStream() {
++ m_originalStream.rdbuf( m_prevBuf );
++ }
++
++ RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
++ auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
++
++ RedirectedStdErr::RedirectedStdErr()
++ : m_cerr( Catch::cerr(), m_rss.get() ),
++ m_clog( Catch::clog(), m_rss.get() )
++ {}
++ auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
++
++ RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
++ : m_redirectedCout(redirectedCout),
++ m_redirectedCerr(redirectedCerr)
++ {}
++
++ RedirectedStreams::~RedirectedStreams() {
++ m_redirectedCout += m_redirectedStdOut.str();
++ m_redirectedCerr += m_redirectedStdErr.str();
++ }
++
++#if defined(CATCH_CONFIG_NEW_CAPTURE)
++
++#if defined(_MSC_VER)
++ TempFile::TempFile() {
++ if (tmpnam_s(m_buffer)) {
++ CATCH_RUNTIME_ERROR("Could not get a temp filename");
++ }
++ if (fopen_s(&m_file, m_buffer, "w+")) {
++ char buffer[100];
++ if (strerror_s(buffer, errno)) {
++ CATCH_RUNTIME_ERROR("Could not translate errno to a string");
++ }
++ CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
++ }
++ }
++#else
++ TempFile::TempFile() {
++ m_file = std::tmpfile();
++ if (!m_file) {
++ CATCH_RUNTIME_ERROR("Could not create a temp file.");
++ }
++ }
++
++#endif
++
++ TempFile::~TempFile() {
++ // TBD: What to do about errors here?
++ std::fclose(m_file);
++ // We manually create the file on Windows only, on Linux
++ // it will be autodeleted
++#if defined(_MSC_VER)
++ std::remove(m_buffer);
++#endif
++ }
++
++
++ FILE* TempFile::getFile() {
++ return m_file;
++ }
++
++ std::string TempFile::getContents() {
++ std::stringstream sstr;
++ char buffer[100] = {};
++ std::rewind(m_file);
++ while (std::fgets(buffer, sizeof(buffer), m_file)) {
++ sstr << buffer;
++ }
++ return sstr.str();
++ }
++
++ OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
++ m_originalStdout(dup(1)),
++ m_originalStderr(dup(2)),
++ m_stdoutDest(stdout_dest),
++ m_stderrDest(stderr_dest) {
++ dup2(fileno(m_stdoutFile.getFile()), 1);
++ dup2(fileno(m_stderrFile.getFile()), 2);
++ }
++
++ OutputRedirect::~OutputRedirect() {
++ Catch::cout() << std::flush;
++ fflush(stdout);
++ // Since we support overriding these streams, we flush cerr
++ // even though std::cerr is unbuffered
++ Catch::cerr() << std::flush;
++ Catch::clog() << std::flush;
++ fflush(stderr);
++
++ dup2(m_originalStdout, 1);
++ dup2(m_originalStderr, 2);
++
++ m_stdoutDest += m_stdoutFile.getContents();
++ m_stderrDest += m_stderrFile.getContents();
++ }
++
++#endif // CATCH_CONFIG_NEW_CAPTURE
++
++} // namespace Catch
++
++#if defined(CATCH_CONFIG_NEW_CAPTURE)
++ #if defined(_MSC_VER)
++ #undef dup
++ #undef dup2
++ #undef fileno
++ #endif
++#endif
++
++
++
++
++#include <limits>
++#include <stdexcept>
++
++namespace Catch {
++
++ Optional<unsigned int> parseUInt(std::string const& input, int base) {
++ auto trimmed = trim( input );
++ // std::stoull is annoying and accepts numbers starting with '-',
++ // it just negates them into unsigned int
++ if ( trimmed.empty() || trimmed[0] == '-' ) {
++ return {};
++ }
++
++ CATCH_TRY {
++ size_t pos = 0;
++ const auto ret = std::stoull( trimmed, &pos, base );
++
++ // We did not consume the whole input, so there is an issue
++ // This can be bunch of different stuff, like multiple numbers
++ // in the input, or invalid digits/characters and so on. Either
++ // way, we do not want to return the partially parsed result.
++ if ( pos != trimmed.size() ) {
++ return {};
++ }
++ // Too large
++ if ( ret > std::numeric_limits<unsigned int>::max() ) {
++ return {};
++ }
++ return static_cast<unsigned int>(ret);
++ }
++ CATCH_CATCH_ANON( std::invalid_argument const& ) {
++ // no conversion could be performed
++ }
++ CATCH_CATCH_ANON( std::out_of_range const& ) {
++ // the input does not fit into an unsigned long long
++ }
++ return {};
++ }
++
++} // namespace Catch
++
++
++
++
++#include <cmath>
++
++namespace Catch {
++
++#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
++ bool isnan(float f) {
++ return std::isnan(f);
++ }
++ bool isnan(double d) {
++ return std::isnan(d);
++ }
++#else
++ // For now we only use this for embarcadero
++ bool isnan(float f) {
++ return std::_isnan(f);
++ }
++ bool isnan(double d) {
++ return std::_isnan(d);
++ }
++#endif
++
++#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
++ float nextafter( float x, float y ) { return std::nextafter( x, y ); }
++ double nextafter( double x, double y ) { return std::nextafter( x, y ); }
++#else
++ float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
++ double nextafter( double x, double y ) { return ::nextafter( x, y ); }
++#endif
++
++} // end namespace Catch
++
++
++
++namespace Catch {
++
++namespace {
++
++#if defined(_MSC_VER)
++#pragma warning(push)
++#pragma warning(disable:4146) // we negate uint32 during the rotate
++#endif
++ // Safe rotr implementation thanks to John Regehr
++ uint32_t rotate_right(uint32_t val, uint32_t count) {
++ const uint32_t mask = 31;
++ count &= mask;
++ return (val >> count) | (val << (-count & mask));
++ }
++
++#if defined(_MSC_VER)
++#pragma warning(pop)
++#endif
++
++}
++
++
++ SimplePcg32::SimplePcg32(result_type seed_) {
++ seed(seed_);
++ }
++
++
++ void SimplePcg32::seed(result_type seed_) {
++ m_state = 0;
++ (*this)();
++ m_state += seed_;
++ (*this)();
++ }
++
++ void SimplePcg32::discard(uint64_t skip) {
++ // We could implement this to run in O(log n) steps, but this
++ // should suffice for our use case.
++ for (uint64_t s = 0; s < skip; ++s) {
++ static_cast<void>((*this)());
++ }
++ }
++
++ SimplePcg32::result_type SimplePcg32::operator()() {
++ // prepare the output value
++ const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
++ const auto output = rotate_right(xorshifted, m_state >> 59u);
++
++ // advance state
++ m_state = m_state * 6364136223846793005ULL + s_inc;
++
++ return output;
++ }
++
++ bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
++ return lhs.m_state == rhs.m_state;
++ }
++
++ bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
++ return lhs.m_state != rhs.m_state;
++ }
++}
++
++
++
++
++
++#include <ctime>
++#include <random>
++
++namespace Catch {
++
++ std::uint32_t generateRandomSeed( GenerateFrom from ) {
++ switch ( from ) {
++ case GenerateFrom::Time:
++ return static_cast<std::uint32_t>( std::time( nullptr ) );
++
++ case GenerateFrom::Default:
++ case GenerateFrom::RandomDevice: {
++ std::random_device rd;
++ return Detail::fillBitsFrom<std::uint32_t>( rd );
++ }
++
++ default:
++ CATCH_ERROR("Unknown generation method");
++ }
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++ struct ReporterRegistry::ReporterRegistryImpl {
++ std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
++ std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
++ factories;
++ };
++
++ ReporterRegistry::ReporterRegistry():
++ m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
++ // Because it is impossible to move out of initializer list,
++ // we have to add the elements manually
++ m_impl->factories["Automake"] =
++ Detail::make_unique<ReporterFactory<AutomakeReporter>>();
++ m_impl->factories["compact"] =
++ Detail::make_unique<ReporterFactory<CompactReporter>>();
++ m_impl->factories["console"] =
++ Detail::make_unique<ReporterFactory<ConsoleReporter>>();
++ m_impl->factories["JUnit"] =
++ Detail::make_unique<ReporterFactory<JunitReporter>>();
++ m_impl->factories["SonarQube"] =
++ Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
++ m_impl->factories["TAP"] =
++ Detail::make_unique<ReporterFactory<TAPReporter>>();
++ m_impl->factories["TeamCity"] =
++ Detail::make_unique<ReporterFactory<TeamCityReporter>>();
++ m_impl->factories["XML"] =
++ Detail::make_unique<ReporterFactory<XmlReporter>>();
++ m_impl->factories["JSON"] =
++ Detail::make_unique<ReporterFactory<JsonReporter>>();
++ }
++
++ ReporterRegistry::~ReporterRegistry() = default;
++
++ IEventListenerPtr
++ ReporterRegistry::create( std::string const& name,
++ ReporterConfig&& config ) const {
++ auto it = m_impl->factories.find( name );
++ if ( it == m_impl->factories.end() ) return nullptr;
++ return it->second->create( CATCH_MOVE( config ) );
++ }
++
++ void ReporterRegistry::registerReporter( std::string const& name,
++ IReporterFactoryPtr factory ) {
++ CATCH_ENFORCE( name.find( "::" ) == name.npos,
++ "'::' is not allowed in reporter name: '" + name +
++ '\'' );
++ auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
++ CATCH_ENFORCE( ret.second,
++ "reporter using '" + name +
++ "' as name was already registered" );
++ }
++ void ReporterRegistry::registerListener(
++ Detail::unique_ptr<EventListenerFactory> factory ) {
++ m_impl->listeners.push_back( CATCH_MOVE( factory ) );
++ }
++
++ std::map<std::string,
++ IReporterFactoryPtr,
++ Detail::CaseInsensitiveLess> const&
++ ReporterRegistry::getFactories() const {
++ return m_impl->factories;
++ }
++
++ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
++ ReporterRegistry::getListeners() const {
++ return m_impl->listeners;
++ }
++} // namespace Catch
++
++
++
++
++
++#include <algorithm>
++
++namespace Catch {
++
++ namespace {
++ struct kvPair {
++ StringRef key, value;
++ };
++
++ kvPair splitKVPair(StringRef kvString) {
++ auto splitPos = static_cast<size_t>(
++ std::find( kvString.begin(), kvString.end(), '=' ) -
++ kvString.begin() );
++
++ return { kvString.substr( 0, splitPos ),
++ kvString.substr( splitPos + 1, kvString.size() ) };
++ }
++ }
++
++ namespace Detail {
++ std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
++ static constexpr auto separator = "::";
++ static constexpr size_t separatorSize = 2;
++
++ size_t separatorPos = 0;
++ auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
++ static_assert(
++ separatorSize == 2,
++ "The code below currently assumes 2 char separator" );
++
++ auto currentPos = startPos;
++ do {
++ while ( currentPos < reporterSpec.size() &&
++ reporterSpec[currentPos] != separator[0] ) {
++ ++currentPos;
++ }
++ if ( currentPos + 1 < reporterSpec.size() &&
++ reporterSpec[currentPos + 1] == separator[1] ) {
++ return currentPos;
++ }
++ ++currentPos;
++ } while ( currentPos < reporterSpec.size() );
++
++ return static_cast<size_t>( -1 );
++ };
++
++ std::vector<std::string> parts;
++
++ while ( separatorPos < reporterSpec.size() ) {
++ const auto nextSeparator = findNextSeparator( separatorPos );
++ parts.push_back( static_cast<std::string>( reporterSpec.substr(
++ separatorPos, nextSeparator - separatorPos ) ) );
++
++ if ( nextSeparator == static_cast<size_t>( -1 ) ) {
++ break;
++ }
++ separatorPos = nextSeparator + separatorSize;
++ }
++
++ // Handle a separator at the end.
++ // This is not a valid spec, but we want to do validation in a
++ // centralized place
++ if ( separatorPos == reporterSpec.size() ) {
++ parts.emplace_back();
++ }
++
++ return parts;
++ }
++
++ Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
++ if ( colourMode == "default" ) {
++ return ColourMode::PlatformDefault;
++ } else if ( colourMode == "ansi" ) {
++ return ColourMode::ANSI;
++ } else if ( colourMode == "win32" ) {
++ return ColourMode::Win32;
++ } else if ( colourMode == "none" ) {
++ return ColourMode::None;
++ } else {
++ return {};
++ }
++ }
++ } // namespace Detail
++
++
++ bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
++ return lhs.m_name == rhs.m_name &&
++ lhs.m_outputFileName == rhs.m_outputFileName &&
++ lhs.m_colourMode == rhs.m_colourMode &&
++ lhs.m_customOptions == rhs.m_customOptions;
++ }
++
++ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
++ auto parts = Detail::splitReporterSpec( reporterSpec );
++
++ assert( parts.size() > 0 && "Split should never return empty vector" );
++
++ std::map<std::string, std::string> kvPairs;
++ Optional<std::string> outputFileName;
++ Optional<ColourMode> colourMode;
++
++ // First part is always reporter name, so we skip it
++ for ( size_t i = 1; i < parts.size(); ++i ) {
++ auto kv = splitKVPair( parts[i] );
++ auto key = kv.key, value = kv.value;
++
++ if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
++ return {};
++ } else if ( key[0] == 'X' ) {
++ // This is a reporter-specific option, we don't check these
++ // apart from basic sanity checks
++ if ( key.size() == 1 ) {
++ return {};
++ }
++
++ auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
++ if ( !ret.second ) {
++ // Duplicated key. We might want to handle this differently,
++ // e.g. by overwriting the existing value?
++ return {};
++ }
++ } else if ( key == "out" ) {
++ // Duplicated key
++ if ( outputFileName ) {
++ return {};
++ }
++ outputFileName = static_cast<std::string>( value );
++ } else if ( key == "colour-mode" ) {
++ // Duplicated key
++ if ( colourMode ) {
++ return {};
++ }
++ colourMode = Detail::stringToColourMode( value );
++ // Parsing failed
++ if ( !colourMode ) {
++ return {};
++ }
++ } else {
++ // Unrecognized option
++ return {};
++ }
++ }
++
++ return ReporterSpec{ CATCH_MOVE( parts[0] ),
++ CATCH_MOVE( outputFileName ),
++ CATCH_MOVE( colourMode ),
++ CATCH_MOVE( kvPairs ) };
++ }
++
++ReporterSpec::ReporterSpec(
++ std::string name,
++ Optional<std::string> outputFileName,
++ Optional<ColourMode> colourMode,
++ std::map<std::string, std::string> customOptions ):
++ m_name( CATCH_MOVE( name ) ),
++ m_outputFileName( CATCH_MOVE( outputFileName ) ),
++ m_colourMode( CATCH_MOVE( colourMode ) ),
++ m_customOptions( CATCH_MOVE( customOptions ) ) {}
++
++} // namespace Catch
++
++
++
++namespace Catch {
++
++ bool isOk( ResultWas::OfType resultType ) {
++ return ( resultType & ResultWas::FailureBit ) == 0;
++ }
++ bool isJustInfo( int flags ) {
++ return flags == ResultWas::Info;
++ }
++
++ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
++ return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
++ }
++
++ bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
++ bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
++
++} // end namespace Catch
++
++
++
++#include <cstdio>
++#include <sstream>
++#include <vector>
++
++namespace Catch {
++
++ // This class encapsulates the idea of a pool of ostringstreams that can be reused.
++ struct StringStreams {
++ std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
++ std::vector<std::size_t> m_unused;
++ std::ostringstream m_referenceStream; // Used for copy state/ flags from
++
++ auto add() -> std::size_t {
++ if( m_unused.empty() ) {
++ m_streams.push_back( Detail::make_unique<std::ostringstream>() );
++ return m_streams.size()-1;
++ }
++ else {
++ auto index = m_unused.back();
++ m_unused.pop_back();
++ return index;
++ }
++ }
++
++ void release( std::size_t index ) {
++ m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
++ m_unused.push_back(index);
++ }
++ };
++
++ ReusableStringStream::ReusableStringStream()
++ : m_index( Singleton<StringStreams>::getMutable().add() ),
++ m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
++ {}
++
++ ReusableStringStream::~ReusableStringStream() {
++ static_cast<std::ostringstream*>( m_oss )->str("");
++ m_oss->clear();
++ Singleton<StringStreams>::getMutable().release( m_index );
++ }
++
++ std::string ReusableStringStream::str() const {
++ return static_cast<std::ostringstream*>( m_oss )->str();
++ }
++
++ void ReusableStringStream::str( std::string const& str ) {
++ static_cast<std::ostringstream*>( m_oss )->str( str );
++ }
++
++
++}
++
++
++
++
++#include <cassert>
++#include <algorithm>
++
++namespace Catch {
++
++ namespace Generators {
++ namespace {
++ struct GeneratorTracker final : TestCaseTracking::TrackerBase,
++ IGeneratorTracker {
++ GeneratorBasePtr m_generator;
++
++ GeneratorTracker(
++ TestCaseTracking::NameAndLocation&& nameAndLocation,
++ TrackerContext& ctx,
++ ITracker* parent ):
++ TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
++
++ static GeneratorTracker*
++ acquire( TrackerContext& ctx,
++ TestCaseTracking::NameAndLocationRef const&
++ nameAndLocation ) {
++ GeneratorTracker* tracker;
++
++ ITracker& currentTracker = ctx.currentTracker();
++ // Under specific circumstances, the generator we want
++ // to acquire is also the current tracker. If this is
++ // the case, we have to avoid looking through current
++ // tracker's children, and instead return the current
++ // tracker.
++ // A case where this check is important is e.g.
++ // for (int i = 0; i < 5; ++i) {
++ // int n = GENERATE(1, 2);
++ // }
++ //
++ // without it, the code above creates 5 nested generators.
++ if ( currentTracker.nameAndLocation() == nameAndLocation ) {
++ auto thisTracker = currentTracker.parent()->findChild(
++ nameAndLocation );
++ assert( thisTracker );
++ assert( thisTracker->isGeneratorTracker() );
++ tracker = static_cast<GeneratorTracker*>( thisTracker );
++ } else if ( ITracker* childTracker =
++ currentTracker.findChild(
++ nameAndLocation ) ) {
++ assert( childTracker );
++ assert( childTracker->isGeneratorTracker() );
++ tracker =
++ static_cast<GeneratorTracker*>( childTracker );
++ } else {
++ return nullptr;
++ }
++
++ if ( !tracker->isComplete() ) { tracker->open(); }
++
++ return tracker;
++ }
++
++ // TrackerBase interface
++ bool isGeneratorTracker() const override { return true; }
++ auto hasGenerator() const -> bool override {
++ return !!m_generator;
++ }
++ void close() override {
++ TrackerBase::close();
++ // If a generator has a child (it is followed by a section)
++ // and none of its children have started, then we must wait
++ // until later to start consuming its values.
++ // This catches cases where `GENERATE` is placed between two
++ // `SECTION`s.
++ // **The check for m_children.empty cannot be removed**.
++ // doing so would break `GENERATE` _not_ followed by
++ // `SECTION`s.
++ const bool should_wait_for_child = [&]() {
++ // No children -> nobody to wait for
++ if ( m_children.empty() ) { return false; }
++ // If at least one child started executing, don't wait
++ if ( std::find_if(
++ m_children.begin(),
++ m_children.end(),
++ []( TestCaseTracking::ITrackerPtr const&
++ tracker ) {
++ return tracker->hasStarted();
++ } ) != m_children.end() ) {
++ return false;
++ }
++
++ // No children have started. We need to check if they
++ // _can_ start, and thus we should wait for them, or
++ // they cannot start (due to filters), and we shouldn't
++ // wait for them
++ ITracker* parent = m_parent;
++ // This is safe: there is always at least one section
++ // tracker in a test case tracking tree
++ while ( !parent->isSectionTracker() ) {
++ parent = parent->parent();
++ }
++ assert( parent &&
++ "Missing root (test case) level section" );
++
++ auto const& parentSection =
++ static_cast<SectionTracker const&>( *parent );
++ auto const& filters = parentSection.getFilters();
++ // No filters -> no restrictions on running sections
++ if ( filters.empty() ) { return true; }
++
++ for ( auto const& child : m_children ) {
++ if ( child->isSectionTracker() &&
++ std::find( filters.begin(),
++ filters.end(),
++ static_cast<SectionTracker const&>(
++ *child )
++ .trimmedName() ) !=
++ filters.end() ) {
++ return true;
++ }
++ }
++ return false;
++ }();
++
++ // This check is a bit tricky, because m_generator->next()
++ // has a side-effect, where it consumes generator's current
++ // value, but we do not want to invoke the side-effect if
++ // this generator is still waiting for any child to start.
++ assert( m_generator && "Tracker without generator" );
++ if ( should_wait_for_child ||
++ ( m_runState == CompletedSuccessfully &&
++ m_generator->countedNext() ) ) {
++ m_children.clear();
++ m_runState = Executing;
++ }
++ }
++
++ // IGeneratorTracker interface
++ auto getGenerator() const -> GeneratorBasePtr const& override {
++ return m_generator;
++ }
++ void setGenerator( GeneratorBasePtr&& generator ) override {
++ m_generator = CATCH_MOVE( generator );
++ }
++ };
++ } // namespace
++ }
++
++ RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
++ : m_runInfo(_config->name()),
++ m_config(_config),
++ m_reporter(CATCH_MOVE(reporter)),
++ m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
++ m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
++ {
++ getCurrentMutableContext().setResultCapture( this );
++ m_reporter->testRunStarting(m_runInfo);
++ }
++
++ RunContext::~RunContext() {
++ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
++ }
++
++ Totals RunContext::runTest(TestCaseHandle const& testCase) {
++ const Totals prevTotals = m_totals;
++
++ auto const& testInfo = testCase.getTestCaseInfo();
++ m_reporter->testCaseStarting(testInfo);
++ m_activeTestCase = &testCase;
++
++
++ ITracker& rootTracker = m_trackerContext.startRun();
++ assert(rootTracker.isSectionTracker());
++ static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
++
++ // We intentionally only seed the internal RNG once per test case,
++ // before it is first invoked. The reason for that is a complex
++ // interplay of generator/section implementation details and the
++ // Random*Generator types.
++ //
++ // The issue boils down to us needing to seed the Random*Generators
++ // with different seed each, so that they return different sequences
++ // of random numbers. We do this by giving them a number from the
++ // shared RNG instance as their seed.
++ //
++ // However, this runs into an issue if the reseeding happens each
++ // time the test case is entered (as opposed to first time only),
++ // because multiple generators could get the same seed, e.g. in
++ // ```cpp
++ // TEST_CASE() {
++ // auto i = GENERATE(take(10, random(0, 100));
++ // SECTION("A") {
++ // auto j = GENERATE(take(10, random(0, 100));
++ // }
++ // SECTION("B") {
++ // auto k = GENERATE(take(10, random(0, 100));
++ // }
++ // }
++ // ```
++ // `i` and `j` would properly return values from different sequences,
++ // but `i` and `k` would return the same sequence, because their seed
++ // would be the same.
++ // (The reason their seeds would be the same is that the generator
++ // for k would be initialized when the test case is entered the second
++ // time, after the shared RNG instance was reset to the same value
++ // it had when the generator for i was initialized.)
++ seedRng( *m_config );
++
++ uint64_t testRuns = 0;
++ std::string redirectedCout;
++ std::string redirectedCerr;
++ do {
++ m_trackerContext.startCycle();
++ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
++
++ m_reporter->testCasePartialStarting(testInfo, testRuns);
++
++ const auto beforeRunTotals = m_totals;
++ std::string oneRunCout, oneRunCerr;
++ runCurrentTest(oneRunCout, oneRunCerr);
++ redirectedCout += oneRunCout;
++ redirectedCerr += oneRunCerr;
++
++ const auto singleRunTotals = m_totals.delta(beforeRunTotals);
++ auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
++
++ m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
++ ++testRuns;
++ } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
++
++ Totals deltaTotals = m_totals.delta(prevTotals);
++ if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
++ deltaTotals.assertions.failed++;
++ deltaTotals.testCases.passed--;
++ deltaTotals.testCases.failed++;
++ }
++ m_totals.testCases += deltaTotals.testCases;
++ m_reporter->testCaseEnded(TestCaseStats(testInfo,
++ deltaTotals,
++ CATCH_MOVE(redirectedCout),
++ CATCH_MOVE(redirectedCerr),
++ aborting()));
++
++ m_activeTestCase = nullptr;
++ m_testCaseTracker = nullptr;
++
++ return deltaTotals;
++ }
++
++
++ void RunContext::assertionEnded(AssertionResult&& result) {
++ if (result.getResultType() == ResultWas::Ok) {
++ m_totals.assertions.passed++;
++ m_lastAssertionPassed = true;
++ } else if (result.getResultType() == ResultWas::ExplicitSkip) {
++ m_totals.assertions.skipped++;
++ m_lastAssertionPassed = true;
++ } else if (!result.succeeded()) {
++ m_lastAssertionPassed = false;
++ if (result.isOk()) {
++ }
++ else if( m_activeTestCase->getTestCaseInfo().okToFail() )
++ m_totals.assertions.failedButOk++;
++ else
++ m_totals.assertions.failed++;
++ }
++ else {
++ m_lastAssertionPassed = true;
++ }
++
++ m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
++
++ if ( result.getResultType() != ResultWas::Warning ) {
++ m_messageScopes.clear();
++ }
++
++ // Reset working state. assertion info will be reset after
++ // populateReaction is run if it is needed
++ m_lastResult = CATCH_MOVE( result );
++ }
++ void RunContext::resetAssertionInfo() {
++ m_lastAssertionInfo.macroName = StringRef();
++ m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
++ m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal;
++ }
++
++ void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
++ m_reporter->assertionStarting( info );
++ }
++
++ bool RunContext::sectionStarted( StringRef sectionName,
++ SourceLineInfo const& sectionLineInfo,
++ Counts& assertions ) {
++ ITracker& sectionTracker =
++ SectionTracker::acquire( m_trackerContext,
++ TestCaseTracking::NameAndLocationRef(
++ sectionName, sectionLineInfo ) );
++
++ if (!sectionTracker.isOpen())
++ return false;
++ m_activeSections.push_back(§ionTracker);
++
++ SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
++ m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
++
++ m_reporter->sectionStarting(sectionInfo);
++
++ assertions = m_totals.assertions;
++
++ return true;
++ }
++ IGeneratorTracker*
++ RunContext::acquireGeneratorTracker( StringRef generatorName,
++ SourceLineInfo const& lineInfo ) {
++ using namespace Generators;
++ GeneratorTracker* tracker = GeneratorTracker::acquire(
++ m_trackerContext,
++ TestCaseTracking::NameAndLocationRef(
++ generatorName, lineInfo ) );
++ m_lastAssertionInfo.lineInfo = lineInfo;
++ return tracker;
++ }
++
++ IGeneratorTracker* RunContext::createGeneratorTracker(
++ StringRef generatorName,
++ SourceLineInfo lineInfo,
++ Generators::GeneratorBasePtr&& generator ) {
++
++ auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
++ auto& currentTracker = m_trackerContext.currentTracker();
++ assert(
++ currentTracker.nameAndLocation() != nameAndLoc &&
++ "Trying to create tracker for a genreator that already has one" );
++
++ auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
++ CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker );
++ auto ret = newTracker.get();
++ currentTracker.addChild( CATCH_MOVE( newTracker ) );
++
++ ret->setGenerator( CATCH_MOVE( generator ) );
++ ret->open();
++ return ret;
++ }
++
++ bool RunContext::testForMissingAssertions(Counts& assertions) {
++ if (assertions.total() != 0)
++ return false;
++ if (!m_config->warnAboutMissingAssertions())
++ return false;
++ if (m_trackerContext.currentTracker().hasChildren())
++ return false;
++ m_totals.assertions.failed++;
++ assertions.failed++;
++ return true;
++ }
++
++ void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
++ Counts assertions = m_totals.assertions - endInfo.prevAssertions;
++ bool missingAssertions = testForMissingAssertions(assertions);
++
++ if (!m_activeSections.empty()) {
++ m_activeSections.back()->close();
++ m_activeSections.pop_back();
++ }
++
++ m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
++ m_messages.clear();
++ m_messageScopes.clear();
++ }
++
++ void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
++ if ( m_unfinishedSections.empty() ) {
++ m_activeSections.back()->fail();
++ } else {
++ m_activeSections.back()->close();
++ }
++ m_activeSections.pop_back();
++
++ m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
++ }
++
++ void RunContext::benchmarkPreparing( StringRef name ) {
++ m_reporter->benchmarkPreparing(name);
++ }
++ void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
++ m_reporter->benchmarkStarting( info );
++ }
++ void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
++ m_reporter->benchmarkEnded( stats );
++ }
++ void RunContext::benchmarkFailed( StringRef error ) {
++ m_reporter->benchmarkFailed( error );
++ }
++
++ void RunContext::pushScopedMessage(MessageInfo const & message) {
++ m_messages.push_back(message);
++ }
++
++ void RunContext::popScopedMessage(MessageInfo const & message) {
++ m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
++ }
++
++ void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
++ m_messageScopes.emplace_back( CATCH_MOVE(builder) );
++ }
++
++ std::string RunContext::getCurrentTestName() const {
++ return m_activeTestCase
++ ? m_activeTestCase->getTestCaseInfo().name
++ : std::string();
++ }
++
++ const AssertionResult * RunContext::getLastResult() const {
++ return &(*m_lastResult);
++ }
++
++ void RunContext::exceptionEarlyReported() {
++ m_shouldReportUnexpected = false;
++ }
++
++ void RunContext::handleFatalErrorCondition( StringRef message ) {
++ // First notify reporter that bad things happened
++ m_reporter->fatalErrorEncountered(message);
++
++ // Don't rebuild the result -- the stringification itself can cause more fatal errors
++ // Instead, fake a result data.
++ AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
++ tempResult.message = static_cast<std::string>(message);
++ AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
++
++ assertionEnded(CATCH_MOVE(result) );
++ resetAssertionInfo();
++
++ // Best effort cleanup for sections that have not been destructed yet
++ // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
++ while (!m_activeSections.empty()) {
++ auto nl = m_activeSections.back()->nameAndLocation();
++ SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
++ sectionEndedEarly(CATCH_MOVE(endInfo));
++ }
++ handleUnfinishedSections();
++
++ // Recreate section for test case (as we will lose the one that was in scope)
++ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
++ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
++
++ Counts assertions;
++ assertions.failed = 1;
++ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
++ m_reporter->sectionEnded(testCaseSectionStats);
++
++ auto const& testInfo = m_activeTestCase->getTestCaseInfo();
++
++ Totals deltaTotals;
++ deltaTotals.testCases.failed = 1;
++ deltaTotals.assertions.failed = 1;
++ m_reporter->testCaseEnded(TestCaseStats(testInfo,
++ deltaTotals,
++ std::string(),
++ std::string(),
++ false));
++ m_totals.testCases.failed++;
++ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
++ }
++
++ bool RunContext::lastAssertionPassed() {
++ return m_lastAssertionPassed;
++ }
++
++ void RunContext::assertionPassed() {
++ m_lastAssertionPassed = true;
++ ++m_totals.assertions.passed;
++ resetAssertionInfo();
++ m_messageScopes.clear();
++ }
++
++ bool RunContext::aborting() const {
++ return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
++ }
++
++ void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
++ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
++ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
++ m_reporter->sectionStarting(testCaseSection);
++ Counts prevAssertions = m_totals.assertions;
++ double duration = 0;
++ m_shouldReportUnexpected = true;
++ m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
++
++ Timer timer;
++ CATCH_TRY {
++ if (m_reporter->getPreferences().shouldRedirectStdOut) {
++#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
++ RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
++
++ timer.start();
++ invokeActiveTestCase();
++#else
++ OutputRedirect r(redirectedCout, redirectedCerr);
++ timer.start();
++ invokeActiveTestCase();
++#endif
++ } else {
++ timer.start();
++ invokeActiveTestCase();
++ }
++ duration = timer.getElapsedSeconds();
++ } CATCH_CATCH_ANON (TestFailureException&) {
++ // This just means the test was aborted due to failure
++ } CATCH_CATCH_ANON (TestSkipException&) {
++ // This just means the test was explicitly skipped
++ } CATCH_CATCH_ALL {
++ // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
++ // are reported without translation at the point of origin.
++ if( m_shouldReportUnexpected ) {
++ AssertionReaction dummyReaction;
++ handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
++ }
++ }
++ Counts assertions = m_totals.assertions - prevAssertions;
++ bool missingAssertions = testForMissingAssertions(assertions);
++
++ m_testCaseTracker->close();
++ handleUnfinishedSections();
++ m_messages.clear();
++ m_messageScopes.clear();
++
++ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
++ m_reporter->sectionEnded(testCaseSectionStats);
++ }
++
++ void RunContext::invokeActiveTestCase() {
++ // We need to engage a handler for signals/structured exceptions
++ // before running the tests themselves, or the binary can crash
++ // without failed test being reported.
++ FatalConditionHandlerGuard _(&m_fatalConditionhandler);
++ // We keep having issue where some compilers warn about an unused
++ // variable, even though the type has non-trivial constructor and
++ // destructor. This is annoying and ugly, but it makes them stfu.
++ (void)_;
++
++ m_activeTestCase->invoke();
++ }
++
++ void RunContext::handleUnfinishedSections() {
++ // If sections ended prematurely due to an exception we stored their
++ // infos here so we can tear them down outside the unwind process.
++ for (auto it = m_unfinishedSections.rbegin(),
++ itEnd = m_unfinishedSections.rend();
++ it != itEnd;
++ ++it)
++ sectionEnded(CATCH_MOVE(*it));
++ m_unfinishedSections.clear();
++ }
++
++ void RunContext::handleExpr(
++ AssertionInfo const& info,
++ ITransientExpression const& expr,
++ AssertionReaction& reaction
++ ) {
++ bool negated = isFalseTest( info.resultDisposition );
++ bool result = expr.getResult() != negated;
++
++ if( result ) {
++ if (!m_includeSuccessfulResults) {
++ assertionPassed();
++ }
++ else {
++ reportExpr(info, ResultWas::Ok, &expr, negated);
++ }
++ }
++ else {
++ reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
++ populateReaction( reaction );
++ }
++ resetAssertionInfo();
++ }
++ void RunContext::reportExpr(
++ AssertionInfo const &info,
++ ResultWas::OfType resultType,
++ ITransientExpression const *expr,
++ bool negated ) {
++
++ m_lastAssertionInfo = info;
++ AssertionResultData data( resultType, LazyExpression( negated ) );
++
++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
++ assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
++
++ assertionEnded( CATCH_MOVE(assertionResult) );
++ }
++
++ void RunContext::handleMessage(
++ AssertionInfo const& info,
++ ResultWas::OfType resultType,
++ StringRef message,
++ AssertionReaction& reaction
++ ) {
++ m_lastAssertionInfo = info;
++
++ AssertionResultData data( resultType, LazyExpression( false ) );
++ data.message = static_cast<std::string>(message);
++ AssertionResult assertionResult{ m_lastAssertionInfo,
++ CATCH_MOVE( data ) };
++
++ const auto isOk = assertionResult.isOk();
++ assertionEnded( CATCH_MOVE(assertionResult) );
++ if ( !isOk ) {
++ populateReaction( reaction );
++ } else if ( resultType == ResultWas::ExplicitSkip ) {
++ // TODO: Need to handle this explicitly, as ExplicitSkip is
++ // considered "OK"
++ reaction.shouldSkip = true;
++ }
++ resetAssertionInfo();
++ }
++ void RunContext::handleUnexpectedExceptionNotThrown(
++ AssertionInfo const& info,
++ AssertionReaction& reaction
++ ) {
++ handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
++ }
++
++ void RunContext::handleUnexpectedInflightException(
++ AssertionInfo const& info,
++ std::string&& message,
++ AssertionReaction& reaction
++ ) {
++ m_lastAssertionInfo = info;
++
++ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
++ data.message = CATCH_MOVE(message);
++ AssertionResult assertionResult{ info, CATCH_MOVE(data) };
++ assertionEnded( CATCH_MOVE(assertionResult) );
++ populateReaction( reaction );
++ resetAssertionInfo();
++ }
++
++ void RunContext::populateReaction( AssertionReaction& reaction ) {
++ reaction.shouldDebugBreak = m_config->shouldDebugBreak();
++ reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
++ }
++
++ void RunContext::handleIncomplete(
++ AssertionInfo const& info
++ ) {
++ using namespace std::string_literals;
++ m_lastAssertionInfo = info;
++
++ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
++ data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
++ assertionEnded( CATCH_MOVE(assertionResult) );
++ resetAssertionInfo();
++ }
++ void RunContext::handleNonExpr(
++ AssertionInfo const &info,
++ ResultWas::OfType resultType,
++ AssertionReaction &reaction
++ ) {
++ m_lastAssertionInfo = info;
++
++ AssertionResultData data( resultType, LazyExpression( false ) );
++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
++
++ const auto isOk = assertionResult.isOk();
++ assertionEnded( CATCH_MOVE(assertionResult) );
++ if ( !isOk ) { populateReaction( reaction ); }
++ resetAssertionInfo();
++ }
++
++
++ IResultCapture& getResultCapture() {
++ if (auto* capture = getCurrentContext().getResultCapture())
++ return *capture;
++ else
++ CATCH_INTERNAL_ERROR("No result capture instance");
++ }
++
++ void seedRng(IConfig const& config) {
++ sharedRng().seed(config.rngSeed());
++ }
++
++ unsigned int rngSeed() {
++ return getCurrentContext().getConfig()->rngSeed();
++ }
++
++}
++
++
++
++namespace Catch {
++
++ Section::Section( SectionInfo&& info ):
++ m_info( CATCH_MOVE( info ) ),
++ m_sectionIncluded(
++ getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
++ // Non-"included" sections will not use the timing information
++ // anyway, so don't bother with the potential syscall.
++ if (m_sectionIncluded) {
++ m_timer.start();
++ }
++ }
++
++ Section::Section( SourceLineInfo const& _lineInfo,
++ StringRef _name,
++ const char* const ):
++ m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
++ m_sectionIncluded(
++ getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
++ // We delay initialization the SectionInfo member until we know
++ // this section needs it, so we avoid allocating std::string for name.
++ // We also delay timer start to avoid the potential syscall unless we
++ // will actually use the result.
++ if ( m_sectionIncluded ) {
++ m_info.name = static_cast<std::string>( _name );
++ m_info.lineInfo = _lineInfo;
++ m_timer.start();
++ }
++ }
++
++ Section::~Section() {
++ if( m_sectionIncluded ) {
++ SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
++ if ( uncaught_exceptions() ) {
++ getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
++ } else {
++ getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
++ }
++ }
++ }
++
++ // This indicates whether the section should be executed or not
++ Section::operator bool() const {
++ return m_sectionIncluded;
++ }
++
++
++} // end namespace Catch
++
++
++
++#include <vector>
++
++namespace Catch {
++
++ namespace {
++ static auto getSingletons() -> std::vector<ISingleton*>*& {
++ static std::vector<ISingleton*>* g_singletons = nullptr;
++ if( !g_singletons )
++ g_singletons = new std::vector<ISingleton*>();
++ return g_singletons;
++ }
++ }
++
++ ISingleton::~ISingleton() = default;
++
++ void addSingleton(ISingleton* singleton ) {
++ getSingletons()->push_back( singleton );
++ }
++ void cleanupSingletons() {
++ auto& singletons = getSingletons();
++ for( auto singleton : *singletons )
++ delete singleton;
++ delete singletons;
++ singletons = nullptr;
++ }
++
++} // namespace Catch
++
++
++
++#include <cstring>
++#include <ostream>
++
++namespace Catch {
++
++ bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
++ return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
++ }
++ bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
++ // We can assume that the same file will usually have the same pointer.
++ // Thus, if the pointers are the same, there is no point in calling the strcmp
++ return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
++ }
++
++ std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
++#ifndef __GNUG__
++ os << info.file << '(' << info.line << ')';
++#else
++ os << info.file << ':' << info.line;
++#endif
++ return os;
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
++ CATCH_TRY {
++ m_exceptions.push_back(exception);
++ } CATCH_CATCH_ALL {
++ // If we run out of memory during start-up there's really not a lot more we can do about it
++ std::terminate();
++ }
++ }
++
++ std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
++ return m_exceptions;
++ }
++#endif
++
++} // end namespace Catch
++
++
++
++
++
++#include <iostream>
++
++namespace Catch {
++
++// If you #define this you must implement these functions
++#if !defined( CATCH_CONFIG_NOSTDOUT )
++ std::ostream& cout() { return std::cout; }
++ std::ostream& cerr() { return std::cerr; }
++ std::ostream& clog() { return std::clog; }
++#endif
++
++} // namespace Catch
++
++
++
++#include <ostream>
++#include <cstring>
++#include <cctype>
++#include <vector>
++
++namespace Catch {
++
++ bool startsWith( std::string const& s, std::string const& prefix ) {
++ return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
++ }
++ bool startsWith( StringRef s, char prefix ) {
++ return !s.empty() && s[0] == prefix;
++ }
++ bool endsWith( std::string const& s, std::string const& suffix ) {
++ return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
++ }
++ bool endsWith( std::string const& s, char suffix ) {
++ return !s.empty() && s[s.size()-1] == suffix;
++ }
++ bool contains( std::string const& s, std::string const& infix ) {
++ return s.find( infix ) != std::string::npos;
++ }
++ void toLowerInPlace( std::string& s ) {
++ for ( char& c : s ) {
++ c = toLower( c );
++ }
++ }
++ std::string toLower( std::string const& s ) {
++ std::string lc = s;
++ toLowerInPlace( lc );
++ return lc;
++ }
++ char toLower(char c) {
++ return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
++ }
++
++ std::string trim( std::string const& str ) {
++ static char const* whitespaceChars = "\n\r\t ";
++ std::string::size_type start = str.find_first_not_of( whitespaceChars );
++ std::string::size_type end = str.find_last_not_of( whitespaceChars );
++
++ return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
++ }
++
++ StringRef trim(StringRef ref) {
++ const auto is_ws = [](char c) {
++ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
++ };
++ size_t real_begin = 0;
++ while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
++ size_t real_end = ref.size();
++ while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
++
++ return ref.substr(real_begin, real_end - real_begin);
++ }
++
++ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
++ std::size_t i = str.find( replaceThis );
++ if (i == std::string::npos) {
++ return false;
++ }
++ std::size_t copyBegin = 0;
++ std::string origStr = CATCH_MOVE(str);
++ str.clear();
++ // There is at least one replacement, so reserve with the best guess
++ // we can make without actually counting the number of occurences.
++ str.reserve(origStr.size() - replaceThis.size() + withThis.size());
++ do {
++ str.append(origStr, copyBegin, i-copyBegin );
++ str += withThis;
++ copyBegin = i + replaceThis.size();
++ if( copyBegin < origStr.size() )
++ i = origStr.find( replaceThis, copyBegin );
++ else
++ i = std::string::npos;
++ } while( i != std::string::npos );
++ if ( copyBegin < origStr.size() ) {
++ str.append(origStr, copyBegin, origStr.size() );
++ }
++ return true;
++ }
++
++ std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
++ std::vector<StringRef> subStrings;
++ std::size_t start = 0;
++ for(std::size_t pos = 0; pos < str.size(); ++pos ) {
++ if( str[pos] == delimiter ) {
++ if( pos - start > 1 )
++ subStrings.push_back( str.substr( start, pos-start ) );
++ start = pos+1;
++ }
++ }
++ if( start < str.size() )
++ subStrings.push_back( str.substr( start, str.size()-start ) );
++ return subStrings;
++ }
++
++ std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
++ os << pluraliser.m_count << ' ' << pluraliser.m_label;
++ if( pluraliser.m_count != 1 )
++ os << 's';
++ return os;
++ }
++
++}
++
++
++
++#include <algorithm>
++#include <ostream>
++#include <cstring>
++#include <cstdint>
++
++namespace Catch {
++ StringRef::StringRef( char const* rawChars ) noexcept
++ : StringRef( rawChars, std::strlen(rawChars) )
++ {}
++
++
++ bool StringRef::operator<(StringRef rhs) const noexcept {
++ if (m_size < rhs.m_size) {
++ return strncmp(m_start, rhs.m_start, m_size) <= 0;
++ }
++ return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
++ }
++
++ int StringRef::compare( StringRef rhs ) const {
++ auto cmpResult =
++ strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
++
++ // This means that strncmp found a difference before the strings
++ // ended, and we can return it directly
++ if ( cmpResult != 0 ) {
++ return cmpResult;
++ }
++
++ // If strings are equal up to length, then their comparison results on
++ // their size
++ if ( m_size < rhs.m_size ) {
++ return -1;
++ } else if ( m_size > rhs.m_size ) {
++ return 1;
++ } else {
++ return 0;
++ }
++ }
++
++ auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
++ return os.write(str.data(), static_cast<std::streamsize>(str.size()));
++ }
++
++ std::string operator+(StringRef lhs, StringRef rhs) {
++ std::string ret;
++ ret.reserve(lhs.size() + rhs.size());
++ ret += lhs;
++ ret += rhs;
++ return ret;
++ }
++
++ auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
++ lhs.append(rhs.data(), rhs.size());
++ return lhs;
++ }
++
++} // namespace Catch
++
++
++
++namespace Catch {
++
++ TagAliasRegistry::~TagAliasRegistry() = default;
++
++ TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
++ auto it = m_registry.find( alias );
++ if( it != m_registry.end() )
++ return &(it->second);
++ else
++ return nullptr;
++ }
++
++ std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
++ std::string expandedTestSpec = unexpandedTestSpec;
++ for( auto const& registryKvp : m_registry ) {
++ std::size_t pos = expandedTestSpec.find( registryKvp.first );
++ if( pos != std::string::npos ) {
++ expandedTestSpec = expandedTestSpec.substr( 0, pos ) +
++ registryKvp.second.tag +
++ expandedTestSpec.substr( pos + registryKvp.first.size() );
++ }
++ }
++ return expandedTestSpec;
++ }
++
++ void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
++ CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
++ "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
++
++ CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
++ "error: tag alias, '" << alias << "' already registered.\n"
++ << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
++ << "\tRedefined at: " << lineInfo );
++ }
++
++ ITagAliasRegistry::~ITagAliasRegistry() = default;
++
++ ITagAliasRegistry const& ITagAliasRegistry::get() {
++ return getRegistryHub().getTagAliasRegistry();
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++ TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
++
++ uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
++ // FNV-1a hash algorithm that is designed for uniqueness:
++ const hash_t prime = 1099511628211u;
++ hash_t hash = 14695981039346656037u;
++ for ( const char c : t.name ) {
++ hash ^= c;
++ hash *= prime;
++ }
++ for ( const char c : t.className ) {
++ hash ^= c;
++ hash *= prime;
++ }
++ for ( const Tag& tag : t.tags ) {
++ for ( const char c : tag.original ) {
++ hash ^= c;
++ hash *= prime;
++ }
++ }
++ hash ^= m_seed;
++ hash *= prime;
++ const uint32_t low{ static_cast<uint32_t>( hash ) };
++ const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
++ return low * high;
++ }
++} // namespace Catch
++
++
++
++
++#include <algorithm>
++#include <set>
++
++namespace Catch {
++
++ namespace {
++ static void enforceNoDuplicateTestCases(
++ std::vector<TestCaseHandle> const& tests ) {
++ auto testInfoCmp = []( TestCaseInfo const* lhs,
++ TestCaseInfo const* rhs ) {
++ return *lhs < *rhs;
++ };
++ std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
++ testInfoCmp );
++ for ( auto const& test : tests ) {
++ const auto infoPtr = &test.getTestCaseInfo();
++ const auto prev = seenTests.insert( infoPtr );
++ CATCH_ENFORCE( prev.second,
++ "error: test case \""
++ << infoPtr->name << "\", with tags \""
++ << infoPtr->tagsAsString()
++ << "\" already defined.\n"
++ << "\tFirst seen at "
++ << ( *prev.first )->lineInfo << "\n"
++ << "\tRedefined at " << infoPtr->lineInfo );
++ }
++ }
++
++ static bool matchTest( TestCaseHandle const& testCase,
++ TestSpec const& testSpec,
++ IConfig const& config ) {
++ return testSpec.matches( testCase.getTestCaseInfo() ) &&
++ isThrowSafe( testCase, config );
++ }
++
++ } // end unnamed namespace
++
++ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
++ switch (config.runOrder()) {
++ case TestRunOrder::Declared:
++ return unsortedTestCases;
++
++ case TestRunOrder::LexicographicallySorted: {
++ std::vector<TestCaseHandle> sorted = unsortedTestCases;
++ std::sort(
++ sorted.begin(),
++ sorted.end(),
++ []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
++ return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
++ }
++ );
++ return sorted;
++ }
++ case TestRunOrder::Randomized: {
++ using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
++
++ TestCaseInfoHasher h{ config.rngSeed() };
++ std::vector<TestWithHash> indexed_tests;
++ indexed_tests.reserve(unsortedTestCases.size());
++
++ for (auto const& handle : unsortedTestCases) {
++ indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
++ }
++
++ std::sort( indexed_tests.begin(),
++ indexed_tests.end(),
++ []( TestWithHash const& lhs, TestWithHash const& rhs ) {
++ if ( lhs.first == rhs.first ) {
++ return lhs.second.getTestCaseInfo() <
++ rhs.second.getTestCaseInfo();
++ }
++ return lhs.first < rhs.first;
++ } );
++
++ std::vector<TestCaseHandle> randomized;
++ randomized.reserve(indexed_tests.size());
++
++ for (auto const& indexed : indexed_tests) {
++ randomized.push_back(indexed.second);
++ }
++
++ return randomized;
++ }
++ }
++
++ CATCH_INTERNAL_ERROR("Unknown test order value!");
++ }
++
++ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
++ return !testCase.getTestCaseInfo().throws() || config.allowThrows();
++ }
++
++ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
++ std::vector<TestCaseHandle> filtered;
++ filtered.reserve( testCases.size() );
++ for (auto const& testCase : testCases) {
++ if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
++ (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
++ filtered.push_back(testCase);
++ }
++ }
++ return createShard(filtered, config.shardCount(), config.shardIndex());
++ }
++ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
++ return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
++ }
++
++ TestRegistry::~TestRegistry() = default;
++
++ void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
++ m_handles.emplace_back(testInfo.get(), testInvoker.get());
++ m_viewed_test_infos.push_back(testInfo.get());
++ m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
++ m_invokers.push_back(CATCH_MOVE(testInvoker));
++ }
++
++ std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
++ return m_viewed_test_infos;
++ }
++
++ std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
++ return m_handles;
++ }
++ std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
++ if( m_sortedFunctions.empty() )
++ enforceNoDuplicateTestCases( m_handles );
++
++ if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
++ m_sortedFunctions = sortTests( config, m_handles );
++ m_currentSortOrder = config.runOrder();
++ }
++ return m_sortedFunctions;
++ }
++
++} // end namespace Catch
++
++
++
++
++#include <algorithm>
++#include <cassert>
++
++#if defined(__clang__)
++# pragma clang diagnostic push
++# pragma clang diagnostic ignored "-Wexit-time-destructors"
++#endif
++
++namespace Catch {
++namespace TestCaseTracking {
++
++ NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
++ : name( CATCH_MOVE(_name) ),
++ location( _location )
++ {}
++
++
++ ITracker::~ITracker() = default;
++
++ void ITracker::markAsNeedingAnotherRun() {
++ m_runState = NeedsAnotherRun;
++ }
++
++ void ITracker::addChild( ITrackerPtr&& child ) {
++ m_children.push_back( CATCH_MOVE(child) );
++ }
++
++ ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
++ auto it = std::find_if(
++ m_children.begin(),
++ m_children.end(),
++ [&nameAndLocation]( ITrackerPtr const& tracker ) {
++ auto const& tnameAndLoc = tracker->nameAndLocation();
++ if ( tnameAndLoc.location.line !=
++ nameAndLocation.location.line ) {
++ return false;
++ }
++ return tnameAndLoc == nameAndLocation;
++ } );
++ return ( it != m_children.end() ) ? it->get() : nullptr;
++ }
++
++ bool ITracker::isSectionTracker() const { return false; }
++ bool ITracker::isGeneratorTracker() const { return false; }
++
++ bool ITracker::isOpen() const {
++ return m_runState != NotStarted && !isComplete();
++ }
++
++ bool ITracker::hasStarted() const { return m_runState != NotStarted; }
++
++ void ITracker::openChild() {
++ if (m_runState != ExecutingChildren) {
++ m_runState = ExecutingChildren;
++ if (m_parent) {
++ m_parent->openChild();
++ }
++ }
++ }
++
++ ITracker& TrackerContext::startRun() {
++ using namespace std::string_literals;
++ m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
++ NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
++ *this,
++ nullptr );
++ m_currentTracker = nullptr;
++ m_runState = Executing;
++ return *m_rootTracker;
++ }
++
++ void TrackerContext::completeCycle() {
++ m_runState = CompletedCycle;
++ }
++
++ bool TrackerContext::completedCycle() const {
++ return m_runState == CompletedCycle;
++ }
++ void TrackerContext::setCurrentTracker( ITracker* tracker ) {
++ m_currentTracker = tracker;
++ }
++
++
++ TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
++ ITracker(CATCH_MOVE(nameAndLocation), parent),
++ m_ctx( ctx )
++ {}
++
++ bool TrackerBase::isComplete() const {
++ return m_runState == CompletedSuccessfully || m_runState == Failed;
++ }
++
++ void TrackerBase::open() {
++ m_runState = Executing;
++ moveToThis();
++ if( m_parent )
++ m_parent->openChild();
++ }
++
++ void TrackerBase::close() {
++
++ // Close any still open children (e.g. generators)
++ while( &m_ctx.currentTracker() != this )
++ m_ctx.currentTracker().close();
++
++ switch( m_runState ) {
++ case NeedsAnotherRun:
++ break;
++
++ case Executing:
++ m_runState = CompletedSuccessfully;
++ break;
++ case ExecutingChildren:
++ if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
++ m_runState = CompletedSuccessfully;
++ break;
++
++ case NotStarted:
++ case CompletedSuccessfully:
++ case Failed:
++ CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
++
++ default:
++ CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
++ }
++ moveToParent();
++ m_ctx.completeCycle();
++ }
++ void TrackerBase::fail() {
++ m_runState = Failed;
++ if( m_parent )
++ m_parent->markAsNeedingAnotherRun();
++ moveToParent();
++ m_ctx.completeCycle();
++ }
++
++ void TrackerBase::moveToParent() {
++ assert( m_parent );
++ m_ctx.setCurrentTracker( m_parent );
++ }
++ void TrackerBase::moveToThis() {
++ m_ctx.setCurrentTracker( this );
++ }
++
++ SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
++ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
++ m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
++ {
++ if( parent ) {
++ while ( !parent->isSectionTracker() ) {
++ parent = parent->parent();
++ }
++
++ SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
++ addNextFilters( parentSection.m_filters );
++ }
++ }
++
++ bool SectionTracker::isComplete() const {
++ bool complete = true;
++
++ if (m_filters.empty()
++ || m_filters[0].empty()
++ || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
++ complete = TrackerBase::isComplete();
++ }
++ return complete;
++ }
++
++ bool SectionTracker::isSectionTracker() const { return true; }
++
++ SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
++ SectionTracker* tracker;
++
++ ITracker& currentTracker = ctx.currentTracker();
++ if ( ITracker* childTracker =
++ currentTracker.findChild( nameAndLocation ) ) {
++ assert( childTracker );
++ assert( childTracker->isSectionTracker() );
++ tracker = static_cast<SectionTracker*>( childTracker );
++ } else {
++ auto newTracker = Catch::Detail::make_unique<SectionTracker>(
++ NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
++ nameAndLocation.location },
++ ctx,
++ ¤tTracker );
++ tracker = newTracker.get();
++ currentTracker.addChild( CATCH_MOVE( newTracker ) );
++ }
++
++ if ( !ctx.completedCycle() ) {
++ tracker->tryOpen();
++ }
++
++ return *tracker;
++ }
++
++ void SectionTracker::tryOpen() {
++ if( !isComplete() )
++ open();
++ }
++
++ void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
++ if( !filters.empty() ) {
++ m_filters.reserve( m_filters.size() + filters.size() + 2 );
++ m_filters.emplace_back(StringRef{}); // Root - should never be consulted
++ m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
++ m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
++ }
++ }
++ void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
++ if( filters.size() > 1 )
++ m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
++ }
++
++ StringRef SectionTracker::trimmedName() const {
++ return m_trimmed_name;
++ }
++
++} // namespace TestCaseTracking
++
++} // namespace Catch
++
++#if defined(__clang__)
++# pragma clang diagnostic pop
++#endif
++
++
++
++
++namespace Catch {
++
++ void throw_test_failure_exception() {
++#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
++ throw TestFailureException{};
++#else
++ CATCH_ERROR( "Test failure requires aborting test!" );
++#endif
++ }
++
++ void throw_test_skip_exception() {
++#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
++ throw Catch::TestSkipException();
++#else
++ CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
++#endif
++ }
++
++} // namespace Catch
++
++
++
++#include <algorithm>
++#include <iterator>
++
++namespace Catch {
++ ITestInvoker::~ITestInvoker() = default;
++
++ namespace {
++ static StringRef extractClassName( StringRef classOrMethodName ) {
++ if ( !startsWith( classOrMethodName, '&' ) ) {
++ return classOrMethodName;
++ }
++
++ // Remove the leading '&' to avoid having to special case it later
++ const auto methodName =
++ classOrMethodName.substr( 1, classOrMethodName.size() );
++
++ auto reverseStart = std::make_reverse_iterator( methodName.end() );
++ auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
++
++ // We make a simplifying assumption that ":" is only present
++ // in the input as part of "::" from C++ typenames (this is
++ // relatively safe assumption because the input is generated
++ // as stringification of type through preprocessor).
++ auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
++ auto secondLastColons =
++ std::find( lastColons + 1, reverseEnd, ':' );
++
++ auto const startIdx = reverseEnd - secondLastColons;
++ auto const classNameSize = secondLastColons - lastColons - 1;
++
++ return methodName.substr(
++ static_cast<std::size_t>( startIdx ),
++ static_cast<std::size_t>( classNameSize ) );
++ }
++
++ class TestInvokerAsFunction final : public ITestInvoker {
++ using TestType = void ( * )();
++ TestType m_testAsFunction;
++
++ public:
++ TestInvokerAsFunction( TestType testAsFunction ) noexcept:
++ m_testAsFunction( testAsFunction ) {}
++
++ void invoke() const override { m_testAsFunction(); }
++ };
++
++ } // namespace
++
++ Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
++ return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
++ }
++
++ AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
++ CATCH_TRY {
++ getMutableRegistryHub()
++ .registerTest(
++ makeTestCaseInfo(
++ extractClassName( classOrMethod ),
++ nameAndTags,
++ lineInfo),
++ CATCH_MOVE(invoker)
++ );
++ } CATCH_CATCH_ALL {
++ // Do not throw when constructing global objects, instead register the exception to be processed later
++ getMutableRegistryHub().registerStartupException();
++ }
++ }
++}
++
++
++
++
++
++namespace Catch {
++
++ TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
++
++ TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
++ m_mode = None;
++ m_exclusion = false;
++ m_arg = m_tagAliases->expandAliases( arg );
++ m_escapeChars.clear();
++ m_substring.reserve(m_arg.size());
++ m_patternName.reserve(m_arg.size());
++ m_realPatternPos = 0;
++
++ for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
++ //if visitChar fails
++ if( !visitChar( m_arg[m_pos] ) ){
++ m_testSpec.m_invalidSpecs.push_back(arg);
++ break;
++ }
++ endMode();
++ return *this;
++ }
++ TestSpec TestSpecParser::testSpec() {
++ addFilter();
++ return CATCH_MOVE(m_testSpec);
++ }
++ bool TestSpecParser::visitChar( char c ) {
++ if( (m_mode != EscapedName) && (c == '\\') ) {
++ escape();
++ addCharToPattern(c);
++ return true;
++ }else if((m_mode != EscapedName) && (c == ',') ) {
++ return separate();
++ }
++
++ switch( m_mode ) {
++ case None:
++ if( processNoneChar( c ) )
++ return true;
++ break;
++ case Name:
++ processNameChar( c );
++ break;
++ case EscapedName:
++ endMode();
++ addCharToPattern(c);
++ return true;
++ default:
++ case Tag:
++ case QuotedName:
++ if( processOtherChar( c ) )
++ return true;
++ break;
++ }
++
++ m_substring += c;
++ if( !isControlChar( c ) ) {
++ m_patternName += c;
++ m_realPatternPos++;
++ }
++ return true;
++ }
++ // Two of the processing methods return true to signal the caller to return
++ // without adding the given character to the current pattern strings
++ bool TestSpecParser::processNoneChar( char c ) {
++ switch( c ) {
++ case ' ':
++ return true;
++ case '~':
++ m_exclusion = true;
++ return false;
++ case '[':
++ startNewMode( Tag );
++ return false;
++ case '"':
++ startNewMode( QuotedName );
++ return false;
++ default:
++ startNewMode( Name );
++ return false;
++ }
++ }
++ void TestSpecParser::processNameChar( char c ) {
++ if( c == '[' ) {
++ if( m_substring == "exclude:" )
++ m_exclusion = true;
++ else
++ endMode();
++ startNewMode( Tag );
++ }
++ }
++ bool TestSpecParser::processOtherChar( char c ) {
++ if( !isControlChar( c ) )
++ return false;
++ m_substring += c;
++ endMode();
++ return true;
++ }
++ void TestSpecParser::startNewMode( Mode mode ) {
++ m_mode = mode;
++ }
++ void TestSpecParser::endMode() {
++ switch( m_mode ) {
++ case Name:
++ case QuotedName:
++ return addNamePattern();
++ case Tag:
++ return addTagPattern();
++ case EscapedName:
++ revertBackToLastMode();
++ return;
++ case None:
++ default:
++ return startNewMode( None );
++ }
++ }
++ void TestSpecParser::escape() {
++ saveLastMode();
++ m_mode = EscapedName;
++ m_escapeChars.push_back(m_realPatternPos);
++ }
++ bool TestSpecParser::isControlChar( char c ) const {
++ switch( m_mode ) {
++ default:
++ return false;
++ case None:
++ return c == '~';
++ case Name:
++ return c == '[';
++ case EscapedName:
++ return true;
++ case QuotedName:
++ return c == '"';
++ case Tag:
++ return c == '[' || c == ']';
++ }
++ }
++
++ void TestSpecParser::addFilter() {
++ if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
++ m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
++ m_currentFilter = TestSpec::Filter();
++ }
++ }
++
++ void TestSpecParser::saveLastMode() {
++ lastMode = m_mode;
++ }
++
++ void TestSpecParser::revertBackToLastMode() {
++ m_mode = lastMode;
++ }
++
++ bool TestSpecParser::separate() {
++ if( (m_mode==QuotedName) || (m_mode==Tag) ){
++ //invalid argument, signal failure to previous scope.
++ m_mode = None;
++ m_pos = m_arg.size();
++ m_substring.clear();
++ m_patternName.clear();
++ m_realPatternPos = 0;
++ return false;
++ }
++ endMode();
++ addFilter();
++ return true; //success
++ }
++
++ std::string TestSpecParser::preprocessPattern() {
++ std::string token = m_patternName;
++ for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
++ token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
++ m_escapeChars.clear();
++ if (startsWith(token, "exclude:")) {
++ m_exclusion = true;
++ token = token.substr(8);
++ }
++
++ m_patternName.clear();
++ m_realPatternPos = 0;
++
++ return token;
++ }
++
++ void TestSpecParser::addNamePattern() {
++ auto token = preprocessPattern();
++
++ if (!token.empty()) {
++ if (m_exclusion) {
++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
++ } else {
++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
++ }
++ }
++ m_substring.clear();
++ m_exclusion = false;
++ m_mode = None;
++ }
++
++ void TestSpecParser::addTagPattern() {
++ auto token = preprocessPattern();
++
++ if (!token.empty()) {
++ // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
++ // we have to create a separate hide tag and shorten the real one
++ if (token.size() > 1 && token[0] == '.') {
++ token.erase(token.begin());
++ if (m_exclusion) {
++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
++ } else {
++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
++ }
++ }
++ if (m_exclusion) {
++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
++ } else {
++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
++ }
++ }
++ m_substring.clear();
++ m_exclusion = false;
++ m_mode = None;
++ }
++
++} // namespace Catch
++
++
++
++#include <algorithm>
++#include <cstring>
++#include <ostream>
++
++namespace {
++ bool isWhitespace( char c ) {
++ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
++ }
++
++ bool isBreakableBefore( char c ) {
++ static const char chars[] = "[({<|";
++ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
++ }
++
++ bool isBreakableAfter( char c ) {
++ static const char chars[] = "])}>.,:;*+-=&/\\";
++ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
++ }
++
++} // namespace
++
++namespace Catch {
++ namespace TextFlow {
++ void AnsiSkippingString::preprocessString() {
++ for ( auto it = m_string.begin(); it != m_string.end(); ) {
++ // try to read through an ansi sequence
++ while ( it != m_string.end() && *it == '\033' &&
++ it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
++ auto cursor = it + 2;
++ while ( cursor != m_string.end() &&
++ ( isdigit( *cursor ) || *cursor == ';' ) ) {
++ ++cursor;
++ }
++ if ( cursor == m_string.end() || *cursor != 'm' ) {
++ break;
++ }
++ // 'm' -> 0xff
++ *cursor = AnsiSkippingString::sentinel;
++ // if we've read an ansi sequence, set the iterator and
++ // return to the top of the loop
++ it = cursor + 1;
++ }
++ if ( it != m_string.end() ) {
++ ++m_size;
++ ++it;
++ }
++ }
++ }
++
++ AnsiSkippingString::AnsiSkippingString( std::string const& text ):
++ m_string( text ) {
++ preprocessString();
++ }
++
++ AnsiSkippingString::AnsiSkippingString( std::string&& text ):
++ m_string( CATCH_MOVE( text ) ) {
++ preprocessString();
++ }
++
++ AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
++ return const_iterator( m_string );
++ }
++
++ AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
++ return const_iterator( m_string, const_iterator::EndTag{} );
++ }
++
++ std::string AnsiSkippingString::substring( const_iterator begin,
++ const_iterator end ) const {
++ // There's one caveat here to an otherwise simple substring: when
++ // making a begin iterator we might have skipped ansi sequences at
++ // the start. If `begin` here is a begin iterator, skipped over
++ // initial ansi sequences, we'll use the true beginning of the
++ // string. Lastly: We need to transform any chars we replaced with
++ // 0xff back to 'm'
++ auto str = std::string( begin == this->begin() ? m_string.begin()
++ : begin.m_it,
++ end.m_it );
++ std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
++ return c == AnsiSkippingString::sentinel ? 'm' : c;
++ } );
++ return str;
++ }
++
++ void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
++ // check if we've landed on an ansi sequence, and if so read through
++ // it
++ while ( m_it != m_string->end() && *m_it == '\033' &&
++ m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) {
++ auto cursor = m_it + 2;
++ while ( cursor != m_string->end() &&
++ ( isdigit( *cursor ) || *cursor == ';' ) ) {
++ ++cursor;
++ }
++ if ( cursor == m_string->end() ||
++ *cursor != AnsiSkippingString::sentinel ) {
++ break;
++ }
++ // if we've read an ansi sequence, set the iterator and
++ // return to the top of the loop
++ m_it = cursor + 1;
++ }
++ }
++
++ void AnsiSkippingString::const_iterator::advance() {
++ assert( m_it != m_string->end() );
++ m_it++;
++ tryParseAnsiEscapes();
++ }
++
++ void AnsiSkippingString::const_iterator::unadvance() {
++ assert( m_it != m_string->begin() );
++ m_it--;
++ // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
++ // (and repeat check)
++ while ( *m_it == AnsiSkippingString::sentinel ) {
++ while ( *m_it != '\033' ) {
++ assert( m_it != m_string->begin() );
++ m_it--;
++ }
++ // if this happens, we must have been a begin iterator that had
++ // skipped over ansi sequences at the start of a string
++ assert( m_it != m_string->begin() );
++ assert( *m_it == '\033' );
++ m_it--;
++ }
++ }
++
++ static bool isBoundary( AnsiSkippingString const& line,
++ AnsiSkippingString::const_iterator it ) {
++ return it == line.end() ||
++ ( isWhitespace( *it ) &&
++ !isWhitespace( *it.oneBefore() ) ) ||
++ isBreakableBefore( *it ) ||
++ isBreakableAfter( *it.oneBefore() );
++ }
++
++ void Column::const_iterator::calcLength() {
++ m_addHyphen = false;
++ m_parsedTo = m_lineStart;
++ AnsiSkippingString const& current_line = m_column.m_string;
++
++ if ( m_parsedTo == current_line.end() ) {
++ m_lineEnd = m_parsedTo;
++ return;
++ }
++
++ assert( m_lineStart != current_line.end() );
++ if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
++
++ const auto maxLineLength = m_column.m_width - indentSize();
++ std::size_t lineLength = 0;
++ while ( m_parsedTo != current_line.end() &&
++ lineLength < maxLineLength && *m_parsedTo != '\n' ) {
++ ++m_parsedTo;
++ ++lineLength;
++ }
++
++ // If we encountered a newline before the column is filled,
++ // then we linebreak at the newline and consider this line
++ // finished.
++ if ( lineLength < maxLineLength ) {
++ m_lineEnd = m_parsedTo;
++ } else {
++ // Look for a natural linebreak boundary in the column
++ // (We look from the end, so that the first found boundary is
++ // the right one)
++ m_lineEnd = m_parsedTo;
++ while ( lineLength > 0 &&
++ !isBoundary( current_line, m_lineEnd ) ) {
++ --lineLength;
++ --m_lineEnd;
++ }
++ while ( lineLength > 0 &&
++ isWhitespace( *m_lineEnd.oneBefore() ) ) {
++ --lineLength;
++ --m_lineEnd;
++ }
++
++ // If we found one, then that is where we linebreak, otherwise
++ // we have to split text with a hyphen
++ if ( lineLength == 0 ) {
++ m_addHyphen = true;
++ m_lineEnd = m_parsedTo.oneBefore();
++ }
++ }
++ }
++
++ size_t Column::const_iterator::indentSize() const {
++ auto initial = m_lineStart == m_column.m_string.begin()
++ ? m_column.m_initialIndent
++ : std::string::npos;
++ return initial == std::string::npos ? m_column.m_indent : initial;
++ }
++
++ std::string Column::const_iterator::addIndentAndSuffix(
++ AnsiSkippingString::const_iterator start,
++ AnsiSkippingString::const_iterator end ) const {
++ std::string ret;
++ const auto desired_indent = indentSize();
++ // ret.reserve( desired_indent + (end - start) + m_addHyphen );
++ ret.append( desired_indent, ' ' );
++ // ret.append( start, end );
++ ret += m_column.m_string.substring( start, end );
++ if ( m_addHyphen ) { ret.push_back( '-' ); }
++
++ return ret;
++ }
++
++ Column::const_iterator::const_iterator( Column const& column ):
++ m_column( column ),
++ m_lineStart( column.m_string.begin() ),
++ m_lineEnd( column.m_string.begin() ),
++ m_parsedTo( column.m_string.begin() ) {
++ assert( m_column.m_width > m_column.m_indent );
++ assert( m_column.m_initialIndent == std::string::npos ||
++ m_column.m_width > m_column.m_initialIndent );
++ calcLength();
++ if ( m_lineStart == m_lineEnd ) {
++ m_lineStart = m_column.m_string.end();
++ }
++ }
++
++ std::string Column::const_iterator::operator*() const {
++ assert( m_lineStart <= m_parsedTo );
++ return addIndentAndSuffix( m_lineStart, m_lineEnd );
++ }
++
++ Column::const_iterator& Column::const_iterator::operator++() {
++ m_lineStart = m_lineEnd;
++ AnsiSkippingString const& current_line = m_column.m_string;
++ if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
++ m_lineStart++;
++ } else {
++ while ( m_lineStart != current_line.end() &&
++ isWhitespace( *m_lineStart ) ) {
++ ++m_lineStart;
++ }
++ }
++
++ if ( m_lineStart != current_line.end() ) { calcLength(); }
++ return *this;
++ }
++
++ Column::const_iterator Column::const_iterator::operator++( int ) {
++ const_iterator prev( *this );
++ operator++();
++ return prev;
++ }
++
++ std::ostream& operator<<( std::ostream& os, Column const& col ) {
++ bool first = true;
++ for ( auto line : col ) {
++ if ( first ) {
++ first = false;
++ } else {
++ os << '\n';
++ }
++ os << line;
++ }
++ return os;
++ }
++
++ Column Spacer( size_t spaceWidth ) {
++ Column ret{ "" };
++ ret.width( spaceWidth );
++ return ret;
++ }
++
++ Columns::iterator::iterator( Columns const& columns, EndTag ):
++ m_columns( columns.m_columns ), m_activeIterators( 0 ) {
++
++ m_iterators.reserve( m_columns.size() );
++ for ( auto const& col : m_columns ) {
++ m_iterators.push_back( col.end() );
++ }
++ }
++
++ Columns::iterator::iterator( Columns const& columns ):
++ m_columns( columns.m_columns ),
++ m_activeIterators( m_columns.size() ) {
++
++ m_iterators.reserve( m_columns.size() );
++ for ( auto const& col : m_columns ) {
++ m_iterators.push_back( col.begin() );
++ }
++ }
++
++ std::string Columns::iterator::operator*() const {
++ std::string row, padding;
++
++ for ( size_t i = 0; i < m_columns.size(); ++i ) {
++ const auto width = m_columns[i].width();
++ if ( m_iterators[i] != m_columns[i].end() ) {
++ std::string col = *m_iterators[i];
++ row += padding;
++ row += col;
++
++ padding.clear();
++ if ( col.size() < width ) {
++ padding.append( width - col.size(), ' ' );
++ }
++ } else {
++ padding.append( width, ' ' );
++ }
++ }
++ return row;
++ }
++
++ Columns::iterator& Columns::iterator::operator++() {
++ for ( size_t i = 0; i < m_columns.size(); ++i ) {
++ if ( m_iterators[i] != m_columns[i].end() ) {
++ ++m_iterators[i];
++ }
++ }
++ return *this;
++ }
++
++ Columns::iterator Columns::iterator::operator++( int ) {
++ iterator prev( *this );
++ operator++();
++ return prev;
++ }
++
++ std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
++ bool first = true;
++ for ( auto line : cols ) {
++ if ( first ) {
++ first = false;
++ } else {
++ os << '\n';
++ }
++ os << line;
++ }
++ return os;
++ }
++
++ Columns operator+( Column const& lhs, Column const& rhs ) {
++ Columns cols;
++ cols += lhs;
++ cols += rhs;
++ return cols;
++ }
++ Columns operator+( Column&& lhs, Column&& rhs ) {
++ Columns cols;
++ cols += CATCH_MOVE( lhs );
++ cols += CATCH_MOVE( rhs );
++ return cols;
++ }
++
++ Columns& operator+=( Columns& lhs, Column const& rhs ) {
++ lhs.m_columns.push_back( rhs );
++ return lhs;
++ }
++ Columns& operator+=( Columns& lhs, Column&& rhs ) {
++ lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
++ return lhs;
++ }
++ Columns operator+( Columns const& lhs, Column const& rhs ) {
++ auto combined( lhs );
++ combined += rhs;
++ return combined;
++ }
++ Columns operator+( Columns&& lhs, Column&& rhs ) {
++ lhs += CATCH_MOVE( rhs );
++ return CATCH_MOVE( lhs );
++ }
++
++ } // namespace TextFlow
++} // namespace Catch
++
++
++
++
++#include <exception>
++
++namespace Catch {
++ bool uncaught_exceptions() {
++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
++ return false;
++#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
++ return std::uncaught_exceptions() > 0;
++#else
++ return std::uncaught_exception();
++#endif
++ }
++} // end namespace Catch
++
++
++
++namespace Catch {
++
++ WildcardPattern::WildcardPattern( std::string const& pattern,
++ CaseSensitive caseSensitivity )
++ : m_caseSensitivity( caseSensitivity ),
++ m_pattern( normaliseString( pattern ) )
++ {
++ if( startsWith( m_pattern, '*' ) ) {
++ m_pattern = m_pattern.substr( 1 );
++ m_wildcard = WildcardAtStart;
++ }
++ if( endsWith( m_pattern, '*' ) ) {
++ m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
++ m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
++ }
++ }
++
++ bool WildcardPattern::matches( std::string const& str ) const {
++ switch( m_wildcard ) {
++ case NoWildcard:
++ return m_pattern == normaliseString( str );
++ case WildcardAtStart:
++ return endsWith( normaliseString( str ), m_pattern );
++ case WildcardAtEnd:
++ return startsWith( normaliseString( str ), m_pattern );
++ case WildcardAtBothEnds:
++ return contains( normaliseString( str ), m_pattern );
++ default:
++ CATCH_INTERNAL_ERROR( "Unknown enum" );
++ }
++ }
++
++ std::string WildcardPattern::normaliseString( std::string const& str ) const {
++ return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
++ }
++}
++
++
++// Note: swapping these two includes around causes MSVC to error out
++// while in /permissive- mode. No, I don't know why.
++// Tested on VS 2019, 18.{3, 4}.x
++
++#include <cstdint>
++#include <iomanip>
++#include <type_traits>
++
++namespace Catch {
++
++namespace {
++
++ size_t trailingBytes(unsigned char c) {
++ if ((c & 0xE0) == 0xC0) {
++ return 2;
++ }
++ if ((c & 0xF0) == 0xE0) {
++ return 3;
++ }
++ if ((c & 0xF8) == 0xF0) {
++ return 4;
++ }
++ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
++ }
++
++ uint32_t headerValue(unsigned char c) {
++ if ((c & 0xE0) == 0xC0) {
++ return c & 0x1F;
++ }
++ if ((c & 0xF0) == 0xE0) {
++ return c & 0x0F;
++ }
++ if ((c & 0xF8) == 0xF0) {
++ return c & 0x07;
++ }
++ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
++ }
++
++ void hexEscapeChar(std::ostream& os, unsigned char c) {
++ std::ios_base::fmtflags f(os.flags());
++ os << "\\x"
++ << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
++ << static_cast<int>(c);
++ os.flags(f);
++ }
++
++ bool shouldNewline(XmlFormatting fmt) {
++ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
++ }
++
++ bool shouldIndent(XmlFormatting fmt) {
++ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
++ }
++
++} // anonymous namespace
++
++ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
++ return static_cast<XmlFormatting>(
++ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
++ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
++ );
++ }
++
++ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
++ return static_cast<XmlFormatting>(
++ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
++ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
++ );
++ }
++
++
++ XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
++ : m_str( str ),
++ m_forWhat( forWhat )
++ {}
++
++ void XmlEncode::encodeTo( std::ostream& os ) const {
++ // Apostrophe escaping not necessary if we always use " to write attributes
++ // (see: http://www.w3.org/TR/xml/#syntax)
++
++ for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
++ unsigned char c = static_cast<unsigned char>(m_str[idx]);
++ switch (c) {
++ case '<': os << "<"; break;
++ case '&': os << "&"; break;
++
++ case '>':
++ // See: http://www.w3.org/TR/xml/#syntax
++ if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
++ os << ">";
++ else
++ os << c;
++ break;
++
++ case '\"':
++ if (m_forWhat == ForAttributes)
++ os << """;
++ else
++ os << c;
++ break;
++
++ default:
++ // Check for control characters and invalid utf-8
++
++ // Escape control characters in standard ascii
++ // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
++ if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
++ hexEscapeChar(os, c);
++ break;
++ }
++
++ // Plain ASCII: Write it to stream
++ if (c < 0x7F) {
++ os << c;
++ break;
++ }
++
++ // UTF-8 territory
++ // Check if the encoding is valid and if it is not, hex escape bytes.
++ // Important: We do not check the exact decoded values for validity, only the encoding format
++ // First check that this bytes is a valid lead byte:
++ // This means that it is not encoded as 1111 1XXX
++ // Or as 10XX XXXX
++ if (c < 0xC0 ||
++ c >= 0xF8) {
++ hexEscapeChar(os, c);
++ break;
++ }
++
++ auto encBytes = trailingBytes(c);
++ // Are there enough bytes left to avoid accessing out-of-bounds memory?
++ if (idx + encBytes - 1 >= m_str.size()) {
++ hexEscapeChar(os, c);
++ break;
++ }
++ // The header is valid, check data
++ // The next encBytes bytes must together be a valid utf-8
++ // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
++ bool valid = true;
++ uint32_t value = headerValue(c);
++ for (std::size_t n = 1; n < encBytes; ++n) {
++ unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
++ valid &= ((nc & 0xC0) == 0x80);
++ value = (value << 6) | (nc & 0x3F);
++ }
++
++ if (
++ // Wrong bit pattern of following bytes
++ (!valid) ||
++ // Overlong encodings
++ (value < 0x80) ||
++ (0x80 <= value && value < 0x800 && encBytes > 2) ||
++ (0x800 < value && value < 0x10000 && encBytes > 3) ||
++ // Encoded value out of range
++ (value >= 0x110000)
++ ) {
++ hexEscapeChar(os, c);
++ break;
++ }
++
++ // If we got here, this is in fact a valid(ish) utf-8 sequence
++ for (std::size_t n = 0; n < encBytes; ++n) {
++ os << m_str[idx + n];
++ }
++ idx += encBytes - 1;
++ break;
++ }
++ }
++ }
++
++ std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
++ xmlEncode.encodeTo( os );
++ return os;
++ }
++
++ XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
++ : m_writer( writer ),
++ m_fmt(fmt)
++ {}
++
++ XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
++ : m_writer( other.m_writer ),
++ m_fmt(other.m_fmt)
++ {
++ other.m_writer = nullptr;
++ other.m_fmt = XmlFormatting::None;
++ }
++ XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
++ if ( m_writer ) {
++ m_writer->endElement();
++ }
++ m_writer = other.m_writer;
++ other.m_writer = nullptr;
++ m_fmt = other.m_fmt;
++ other.m_fmt = XmlFormatting::None;
++ return *this;
++ }
++
++
++ XmlWriter::ScopedElement::~ScopedElement() {
++ if (m_writer) {
++ m_writer->endElement(m_fmt);
++ }
++ }
++
++ XmlWriter::ScopedElement&
++ XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
++ m_writer->writeText( text, fmt );
++ return *this;
++ }
++
++ XmlWriter::ScopedElement&
++ XmlWriter::ScopedElement::writeAttribute( StringRef name,
++ StringRef attribute ) {
++ m_writer->writeAttribute( name, attribute );
++ return *this;
++ }
++
++
++ XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
++ {
++ writeDeclaration();
++ }
++
++ XmlWriter::~XmlWriter() {
++ while (!m_tags.empty()) {
++ endElement();
++ }
++ newlineIfNecessary();
++ }
++
++ XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
++ ensureTagClosed();
++ newlineIfNecessary();
++ if (shouldIndent(fmt)) {
++ m_os << m_indent;
++ m_indent += " ";
++ }
++ m_os << '<' << name;
++ m_tags.push_back( name );
++ m_tagIsOpen = true;
++ applyFormatting(fmt);
++ return *this;
++ }
++
++ XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
++ ScopedElement scoped( this, fmt );
++ startElement( name, fmt );
++ return scoped;
++ }
++
++ XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
++ m_indent = m_indent.substr(0, m_indent.size() - 2);
++
++ if( m_tagIsOpen ) {
++ m_os << "/>";
++ m_tagIsOpen = false;
++ } else {
++ newlineIfNecessary();
++ if (shouldIndent(fmt)) {
++ m_os << m_indent;
++ }
++ m_os << "</" << m_tags.back() << '>';
++ }
++ m_os << std::flush;
++ applyFormatting(fmt);
++ m_tags.pop_back();
++ return *this;
++ }
++
++ XmlWriter& XmlWriter::writeAttribute( StringRef name,
++ StringRef attribute ) {
++ if( !name.empty() && !attribute.empty() )
++ m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
++ return *this;
++ }
++
++ XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
++ writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
++ return *this;
++ }
++
++ XmlWriter& XmlWriter::writeAttribute( StringRef name,
++ char const* attribute ) {
++ writeAttribute( name, StringRef( attribute ) );
++ return *this;
++ }
++
++ XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
++ CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
++ if( !text.empty() ){
++ bool tagWasOpen = m_tagIsOpen;
++ ensureTagClosed();
++ if (tagWasOpen && shouldIndent(fmt)) {
++ m_os << m_indent;
++ }
++ m_os << XmlEncode( text, XmlEncode::ForTextNodes );
++ applyFormatting(fmt);
++ }
++ return *this;
++ }
++
++ XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
++ ensureTagClosed();
++ if (shouldIndent(fmt)) {
++ m_os << m_indent;
++ }
++ m_os << "<!-- " << text << " -->";
++ applyFormatting(fmt);
++ return *this;
++ }
++
++ void XmlWriter::writeStylesheetRef( StringRef url ) {
++ m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
++ }
++
++ void XmlWriter::ensureTagClosed() {
++ if( m_tagIsOpen ) {
++ m_os << '>' << std::flush;
++ newlineIfNecessary();
++ m_tagIsOpen = false;
++ }
++ }
++
++ void XmlWriter::applyFormatting(XmlFormatting fmt) {
++ m_needsNewline = shouldNewline(fmt);
++ }
++
++ void XmlWriter::writeDeclaration() {
++ m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
++ }
++
++ void XmlWriter::newlineIfNecessary() {
++ if( m_needsNewline ) {
++ m_os << '\n' << std::flush;
++ m_needsNewline = false;
++ }
++ }
++}
++
++
++
++
++
++namespace Catch {
++namespace Matchers {
++
++ std::string MatcherUntypedBase::toString() const {
++ if (m_cachedToString.empty()) {
++ m_cachedToString = describe();
++ }
++ return m_cachedToString;
++ }
++
++ MatcherUntypedBase::~MatcherUntypedBase() = default;
++
++} // namespace Matchers
++} // namespace Catch
++
++
++
++
++namespace Catch {
++namespace Matchers {
++
++ std::string IsEmptyMatcher::describe() const {
++ return "is empty";
++ }
++
++ std::string HasSizeMatcher::describe() const {
++ ReusableStringStream sstr;
++ sstr << "has size == " << m_target_size;
++ return sstr.str();
++ }
++
++ IsEmptyMatcher IsEmpty() {
++ return {};
++ }
++
++ HasSizeMatcher SizeIs(std::size_t sz) {
++ return HasSizeMatcher{ sz };
++ }
++
++} // end namespace Matchers
++} // end namespace Catch
++
++
++
++namespace Catch {
++namespace Matchers {
++
++bool ExceptionMessageMatcher::match(std::exception const& ex) const {
++ return ex.what() == m_message;
++}
++
++std::string ExceptionMessageMatcher::describe() const {
++ return "exception message matches \"" + m_message + '"';
++}
++
++ExceptionMessageMatcher Message(std::string const& message) {
++ return ExceptionMessageMatcher(message);
++}
++
++} // namespace Matchers
++} // namespace Catch
++
++
++
++#include <algorithm>
++#include <cmath>
++#include <cstdlib>
++#include <cstdint>
++#include <sstream>
++#include <iomanip>
++#include <limits>
++
++
++namespace Catch {
++namespace {
++
++ template <typename FP>
++ bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
++ // Comparison with NaN should always be false.
++ // This way we can rule it out before getting into the ugly details
++ if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
++ return false;
++ }
++
++ // This should also handle positive and negative zeros, infinities
++ const auto ulpDist = ulpDistance(lhs, rhs);
++
++ return ulpDist <= maxUlpDiff;
++ }
++
++
++template <typename FP>
++FP step(FP start, FP direction, uint64_t steps) {
++ for (uint64_t i = 0; i < steps; ++i) {
++ start = Catch::nextafter(start, direction);
++ }
++ return start;
++}
++
++// Performs equivalent check of std::fabs(lhs - rhs) <= margin
++// But without the subtraction to allow for INFINITY in comparison
++bool marginComparison(double lhs, double rhs, double margin) {
++ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
++}
++
++template <typename FloatingPoint>
++void write(std::ostream& out, FloatingPoint num) {
++ out << std::scientific
++ << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
++ << num;
++}
++
++} // end anonymous namespace
++
++namespace Matchers {
++namespace Detail {
++
++ enum class FloatingPointKind : uint8_t {
++ Float,
++ Double
++ };
++
++} // end namespace Detail
++
++
++ WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
++ :m_target{ target }, m_margin{ margin } {
++ CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
++ << " Margin has to be non-negative.");
++ }
++
++ // Performs equivalent check of std::fabs(lhs - rhs) <= margin
++ // But without the subtraction to allow for INFINITY in comparison
++ bool WithinAbsMatcher::match(double const& matchee) const {
++ return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
++ }
++
++ std::string WithinAbsMatcher::describe() const {
++ return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
++ }
++
++
++ WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
++ :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
++ CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
++ || m_ulps < (std::numeric_limits<uint32_t>::max)(),
++ "Provided ULP is impossibly large for a float comparison.");
++ CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
++ "WithinUlp matcher only supports platforms with "
++ "IEEE-754 compatible floating point representation" );
++ }
++
++#if defined(__clang__)
++#pragma clang diagnostic push
++// Clang <3.5 reports on the default branch in the switch below
++#pragma clang diagnostic ignored "-Wunreachable-code"
++#endif
++
++ bool WithinUlpsMatcher::match(double const& matchee) const {
++ switch (m_type) {
++ case Detail::FloatingPointKind::Float:
++ return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
++ case Detail::FloatingPointKind::Double:
++ return almostEqualUlps<double>(matchee, m_target, m_ulps);
++ default:
++ CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
++ }
++ }
++
++#if defined(__clang__)
++#pragma clang diagnostic pop
++#endif
++
++ std::string WithinUlpsMatcher::describe() const {
++ std::stringstream ret;
++
++ ret << "is within " << m_ulps << " ULPs of ";
++
++ if (m_type == Detail::FloatingPointKind::Float) {
++ write(ret, static_cast<float>(m_target));
++ ret << 'f';
++ } else {
++ write(ret, m_target);
++ }
++
++ ret << " ([";
++ if (m_type == Detail::FloatingPointKind::Double) {
++ write( ret,
++ step( m_target,
++ -std::numeric_limits<double>::infinity(),
++ m_ulps ) );
++ ret << ", ";
++ write( ret,
++ step( m_target,
++ std::numeric_limits<double>::infinity(),
++ m_ulps ) );
++ } else {
++ // We have to cast INFINITY to float because of MinGW, see #1782
++ write( ret,
++ step( static_cast<float>( m_target ),
++ -std::numeric_limits<float>::infinity(),
++ m_ulps ) );
++ ret << ", ";
++ write( ret,
++ step( static_cast<float>( m_target ),
++ std::numeric_limits<float>::infinity(),
++ m_ulps ) );
++ }
++ ret << "])";
++
++ return ret.str();
++ }
++
++ WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
++ m_target(target),
++ m_epsilon(epsilon){
++ CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
++ CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense.");
++ }
++
++ bool WithinRelMatcher::match(double const& matchee) const {
++ const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
++ return marginComparison(matchee, m_target,
++ std::isinf(relMargin)? 0 : relMargin);
++ }
++
++ std::string WithinRelMatcher::describe() const {
++ Catch::ReusableStringStream sstr;
++ sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
++ return sstr.str();
++ }
++
++
++WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
++ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
++}
++
++WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
++ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
++}
++
++WithinAbsMatcher WithinAbs(double target, double margin) {
++ return WithinAbsMatcher(target, margin);
++}
++
++WithinRelMatcher WithinRel(double target, double eps) {
++ return WithinRelMatcher(target, eps);
++}
++
++WithinRelMatcher WithinRel(double target) {
++ return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
++}
++
++WithinRelMatcher WithinRel(float target, float eps) {
++ return WithinRelMatcher(target, eps);
++}
++
++WithinRelMatcher WithinRel(float target) {
++ return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
++}
++
++
++
++bool IsNaNMatcher::match( double const& matchee ) const {
++ return std::isnan( matchee );
++}
++
++std::string IsNaNMatcher::describe() const {
++ using namespace std::string_literals;
++ return "is NaN"s;
++}
++
++IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
++
++ } // namespace Matchers
++} // namespace Catch
++
++
++
++
++std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
++ if (desc.empty()) {
++ return "matches undescribed predicate";
++ } else {
++ return "matches predicate: \"" + desc + '"';
++ }
++}
++
++
++
++namespace Catch {
++ namespace Matchers {
++ std::string AllTrueMatcher::describe() const { return "contains only true"; }
++
++ AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
++
++ std::string NoneTrueMatcher::describe() const { return "contains no true"; }
++
++ NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
++
++ std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
++
++ AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
++ } // namespace Matchers
++} // namespace Catch
++
++
++
++#include <regex>
++
++namespace Catch {
++namespace Matchers {
++
++ CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
++ : m_caseSensitivity( caseSensitivity ),
++ m_str( adjustString( str ) )
++ {}
++ std::string CasedString::adjustString( std::string const& str ) const {
++ return m_caseSensitivity == CaseSensitive::No
++ ? toLower( str )
++ : str;
++ }
++ StringRef CasedString::caseSensitivitySuffix() const {
++ return m_caseSensitivity == CaseSensitive::Yes
++ ? StringRef()
++ : " (case insensitive)"_sr;
++ }
++
++
++ StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
++ : m_comparator( comparator ),
++ m_operation( operation ) {
++ }
++
++ std::string StringMatcherBase::describe() const {
++ std::string description;
++ description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
++ m_comparator.caseSensitivitySuffix().size());
++ description += m_operation;
++ description += ": \"";
++ description += m_comparator.m_str;
++ description += '"';
++ description += m_comparator.caseSensitivitySuffix();
++ return description;
++ }
++
++ StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
++
++ bool StringEqualsMatcher::match( std::string const& source ) const {
++ return m_comparator.adjustString( source ) == m_comparator.m_str;
++ }
++
++
++ StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
++
++ bool StringContainsMatcher::match( std::string const& source ) const {
++ return contains( m_comparator.adjustString( source ), m_comparator.m_str );
++ }
++
++
++ StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
++
++ bool StartsWithMatcher::match( std::string const& source ) const {
++ return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
++ }
++
++
++ EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
++
++ bool EndsWithMatcher::match( std::string const& source ) const {
++ return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
++ }
++
++
++
++ RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
++
++ bool RegexMatcher::match(std::string const& matchee) const {
++ auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
++ if (m_caseSensitivity == CaseSensitive::No) {
++ flags |= std::regex::icase;
++ }
++ auto reg = std::regex(m_regex, flags);
++ return std::regex_match(matchee, reg);
++ }
++
++ std::string RegexMatcher::describe() const {
++ return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
++ }
++
++
++ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
++ return StringEqualsMatcher( CasedString( str, caseSensitivity) );
++ }
++ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
++ return StringContainsMatcher( CasedString( str, caseSensitivity) );
++ }
++ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
++ return EndsWithMatcher( CasedString( str, caseSensitivity) );
++ }
++ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
++ return StartsWithMatcher( CasedString( str, caseSensitivity) );
++ }
++
++ RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
++ return RegexMatcher(regex, caseSensitivity);
++ }
++
++} // namespace Matchers
++} // namespace Catch
++
++
++
++namespace Catch {
++namespace Matchers {
++ MatcherGenericBase::~MatcherGenericBase() = default;
++
++ namespace Detail {
++
++ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
++ std::string description;
++ std::size_t combined_size = 4;
++ for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
++ combined_size += desc->size();
++ }
++ combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
++
++ description.reserve(combined_size);
++
++ description += "( ";
++ bool first = true;
++ for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
++ if( first )
++ first = false;
++ else
++ description += combine;
++ description += *desc;
++ }
++ description += " )";
++ return description;
++ }
++
++ } // namespace Detail
++} // namespace Matchers
++} // namespace Catch
++
++
++
++
++namespace Catch {
++
++ // This is the general overload that takes a any string matcher
++ // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
++ // the Equals matcher (so the header does not mention matchers)
++ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
++ std::string exceptionMessage = Catch::translateActiveException();
++ MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
++ handler.handleExpr( expr );
++ }
++
++} // namespace Catch
++
++
++
++#include <ostream>
++
++namespace Catch {
++
++ AutomakeReporter::~AutomakeReporter() = default;
++
++ void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
++ // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
++ m_stream << ":test-result: ";
++ if ( _testCaseStats.totals.testCases.skipped > 0 ) {
++ m_stream << "SKIP";
++ } else if (_testCaseStats.totals.assertions.allPassed()) {
++ m_stream << "PASS";
++ } else if (_testCaseStats.totals.assertions.allOk()) {
++ m_stream << "XFAIL";
++ } else {
++ m_stream << "FAIL";
++ }
++ m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
++ StreamingReporterBase::testCaseEnded(_testCaseStats);
++ }
++
++ void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
++ m_stream << ":test-result: SKIP " << testInfo.name << '\n';
++ }
++
++} // end namespace Catch
++
++
++
++
++
++
++namespace Catch {
++ ReporterBase::ReporterBase( ReporterConfig&& config ):
++ IEventListener( config.fullConfig() ),
++ m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
++ m_stream( m_wrapped_stream->stream() ),
++ m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
++ m_customOptions( config.customOptions() )
++ {}
++
++ ReporterBase::~ReporterBase() = default;
++
++ void ReporterBase::listReporters(
++ std::vector<ReporterDescription> const& descriptions ) {
++ defaultListReporters(m_stream, descriptions, m_config->verbosity());
++ }
++
++ void ReporterBase::listListeners(
++ std::vector<ListenerDescription> const& descriptions ) {
++ defaultListListeners( m_stream, descriptions );
++ }
++
++ void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
++ defaultListTests(m_stream,
++ m_colour.get(),
++ tests,
++ m_config->hasTestFilters(),
++ m_config->verbosity());
++ }
++
++ void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
++ defaultListTags( m_stream, tags, m_config->hasTestFilters() );
++ }
++
++} // namespace Catch
++
++
++
++
++#include <ostream>
++
++namespace Catch {
++namespace {
++
++ // Colour::LightGrey
++ static constexpr Colour::Code compactDimColour = Colour::FileName;
++
++#ifdef CATCH_PLATFORM_MAC
++ static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
++ static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
++#else
++ static constexpr Catch::StringRef compactFailedString = "failed"_sr;
++ static constexpr Catch::StringRef compactPassedString = "passed"_sr;
++#endif
++
++// Implementation of CompactReporter formatting
++class AssertionPrinter {
++public:
++ AssertionPrinter& operator= (AssertionPrinter const&) = delete;
++ AssertionPrinter(AssertionPrinter const&) = delete;
++ AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
++ : stream(_stream)
++ , result(_stats.assertionResult)
++ , messages(_stats.infoMessages)
++ , itMessage(_stats.infoMessages.begin())
++ , printInfoMessages(_printInfoMessages)
++ , colourImpl(colourImpl_)
++ {}
++
++ void print() {
++ printSourceInfo();
++
++ itMessage = messages.begin();
++
++ switch (result.getResultType()) {
++ case ResultWas::Ok:
++ printResultType(Colour::ResultSuccess, compactPassedString);
++ printOriginalExpression();
++ printReconstructedExpression();
++ if (!result.hasExpression())
++ printRemainingMessages(Colour::None);
++ else
++ printRemainingMessages();
++ break;
++ case ResultWas::ExpressionFailed:
++ if (result.isOk())
++ printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
++ else
++ printResultType(Colour::Error, compactFailedString);
++ printOriginalExpression();
++ printReconstructedExpression();
++ printRemainingMessages();
++ break;
++ case ResultWas::ThrewException:
++ printResultType(Colour::Error, compactFailedString);
++ printIssue("unexpected exception with message:");
++ printMessage();
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::FatalErrorCondition:
++ printResultType(Colour::Error, compactFailedString);
++ printIssue("fatal error condition with message:");
++ printMessage();
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::DidntThrowException:
++ printResultType(Colour::Error, compactFailedString);
++ printIssue("expected exception, got none");
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::Info:
++ printResultType(Colour::None, "info"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ case ResultWas::Warning:
++ printResultType(Colour::None, "warning"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ case ResultWas::ExplicitFailure:
++ printResultType(Colour::Error, compactFailedString);
++ printIssue("explicitly");
++ printRemainingMessages(Colour::None);
++ break;
++ case ResultWas::ExplicitSkip:
++ printResultType(Colour::Skip, "skipped"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ // These cases are here to prevent compiler warnings
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ printResultType(Colour::Error, "** internal error **");
++ break;
++ }
++ }
++
++private:
++ void printSourceInfo() const {
++ stream << colourImpl->guardColour( Colour::FileName )
++ << result.getSourceInfo() << ':';
++ }
++
++ void printResultType(Colour::Code colour, StringRef passOrFail) const {
++ if (!passOrFail.empty()) {
++ stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
++ stream << ':';
++ }
++ }
++
++ void printIssue(char const* issue) const {
++ stream << ' ' << issue;
++ }
++
++ void printExpressionWas() {
++ if (result.hasExpression()) {
++ stream << ';';
++ {
++ stream << colourImpl->guardColour(compactDimColour) << " expression was:";
++ }
++ printOriginalExpression();
++ }
++ }
++
++ void printOriginalExpression() const {
++ if (result.hasExpression()) {
++ stream << ' ' << result.getExpression();
++ }
++ }
++
++ void printReconstructedExpression() const {
++ if (result.hasExpandedExpression()) {
++ stream << colourImpl->guardColour(compactDimColour) << " for: ";
++ stream << result.getExpandedExpression();
++ }
++ }
++
++ void printMessage() {
++ if (itMessage != messages.end()) {
++ stream << " '" << itMessage->message << '\'';
++ ++itMessage;
++ }
++ }
++
++ void printRemainingMessages(Colour::Code colour = compactDimColour) {
++ if (itMessage == messages.end())
++ return;
++
++ const auto itEnd = messages.cend();
++ const auto N = static_cast<std::size_t>(itEnd - itMessage);
++
++ stream << colourImpl->guardColour( colour ) << " with "
++ << pluralise( N, "message"_sr ) << ':';
++
++ while (itMessage != itEnd) {
++ // If this assertion is a warning ignore any INFO messages
++ if (printInfoMessages || itMessage->type != ResultWas::Info) {
++ printMessage();
++ if (itMessage != itEnd) {
++ stream << colourImpl->guardColour(compactDimColour) << " and";
++ }
++ continue;
++ }
++ ++itMessage;
++ }
++ }
++
++private:
++ std::ostream& stream;
++ AssertionResult const& result;
++ std::vector<MessageInfo> const& messages;
++ std::vector<MessageInfo>::const_iterator itMessage;
++ bool printInfoMessages;
++ ColourImpl* colourImpl;
++};
++
++} // anon namespace
++
++ std::string CompactReporter::getDescription() {
++ return "Reports test results on a single line, suitable for IDEs";
++ }
++
++ void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
++ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
++ }
++
++ void CompactReporter::testRunStarting( TestRunInfo const& ) {
++ if ( m_config->testSpec().hasFilters() ) {
++ m_stream << m_colour->guardColour( Colour::BrightYellow )
++ << "Filters: "
++ << m_config->testSpec()
++ << '\n';
++ }
++ m_stream << "RNG seed: " << getSeed() << '\n';
++ }
++
++ void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
++ AssertionResult const& result = _assertionStats.assertionResult;
++
++ bool printInfoMessages = true;
++
++ // Drop out if result was successful and we're not printing those
++ if( !m_config->includeSuccessfulResults() && result.isOk() ) {
++ if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
++ return;
++ printInfoMessages = false;
++ }
++
++ AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
++ printer.print();
++
++ m_stream << '\n' << std::flush;
++ }
++
++ void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
++ double dur = _sectionStats.durationInSeconds;
++ if ( shouldShowDuration( *m_config, dur ) ) {
++ m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
++ }
++ }
++
++ void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
++ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
++ m_stream << "\n\n" << std::flush;
++ StreamingReporterBase::testRunEnded( _testRunStats );
++ }
++
++ CompactReporter::~CompactReporter() = default;
++
++} // end namespace Catch
++
++
++
++
++#include <cstdio>
++
++#if defined(_MSC_VER)
++#pragma warning(push)
++#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
++ // Note that 4062 (not all labels are handled and default is missing) is enabled
++#endif
++
++#if defined(__clang__)
++# pragma clang diagnostic push
++// For simplicity, benchmarking-only helpers are always enabled
++# pragma clang diagnostic ignored "-Wunused-function"
++#endif
++
++
++
++namespace Catch {
++
++namespace {
++
++// Formatter impl for ConsoleReporter
++class ConsoleAssertionPrinter {
++public:
++ ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
++ ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
++ ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
++ : stream(_stream),
++ stats(_stats),
++ result(_stats.assertionResult),
++ colour(Colour::None),
++ messages(_stats.infoMessages),
++ colourImpl(colourImpl_),
++ printInfoMessages(_printInfoMessages) {
++ switch (result.getResultType()) {
++ case ResultWas::Ok:
++ colour = Colour::Success;
++ passOrFail = "PASSED"_sr;
++ //if( result.hasMessage() )
++ if (messages.size() == 1)
++ messageLabel = "with message"_sr;
++ if (messages.size() > 1)
++ messageLabel = "with messages"_sr;
++ break;
++ case ResultWas::ExpressionFailed:
++ if (result.isOk()) {
++ colour = Colour::Success;
++ passOrFail = "FAILED - but was ok"_sr;
++ } else {
++ colour = Colour::Error;
++ passOrFail = "FAILED"_sr;
++ }
++ if (messages.size() == 1)
++ messageLabel = "with message"_sr;
++ if (messages.size() > 1)
++ messageLabel = "with messages"_sr;
++ break;
++ case ResultWas::ThrewException:
++ colour = Colour::Error;
++ passOrFail = "FAILED"_sr;
++ // todo switch
++ switch (messages.size()) { case 0:
++ messageLabel = "due to unexpected exception with "_sr;
++ break;
++ case 1:
++ messageLabel = "due to unexpected exception with message"_sr;
++ break;
++ default:
++ messageLabel = "due to unexpected exception with messages"_sr;
++ break;
++ }
++ break;
++ case ResultWas::FatalErrorCondition:
++ colour = Colour::Error;
++ passOrFail = "FAILED"_sr;
++ messageLabel = "due to a fatal error condition"_sr;
++ break;
++ case ResultWas::DidntThrowException:
++ colour = Colour::Error;
++ passOrFail = "FAILED"_sr;
++ messageLabel = "because no exception was thrown where one was expected"_sr;
++ break;
++ case ResultWas::Info:
++ messageLabel = "info"_sr;
++ break;
++ case ResultWas::Warning:
++ messageLabel = "warning"_sr;
++ break;
++ case ResultWas::ExplicitFailure:
++ passOrFail = "FAILED"_sr;
++ colour = Colour::Error;
++ if (messages.size() == 1)
++ messageLabel = "explicitly with message"_sr;
++ if (messages.size() > 1)
++ messageLabel = "explicitly with messages"_sr;
++ break;
++ case ResultWas::ExplicitSkip:
++ colour = Colour::Skip;
++ passOrFail = "SKIPPED"_sr;
++ if (messages.size() == 1)
++ messageLabel = "explicitly with message"_sr;
++ if (messages.size() > 1)
++ messageLabel = "explicitly with messages"_sr;
++ break;
++ // These cases are here to prevent compiler warnings
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ passOrFail = "** internal error **"_sr;
++ colour = Colour::Error;
++ break;
++ }
++ }
++
++ void print() const {
++ printSourceInfo();
++ if (stats.totals.assertions.total() > 0) {
++ printResultType();
++ printOriginalExpression();
++ printReconstructedExpression();
++ } else {
++ stream << '\n';
++ }
++ printMessage();
++ }
++
++private:
++ void printResultType() const {
++ if (!passOrFail.empty()) {
++ stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
++ }
++ }
++ void printOriginalExpression() const {
++ if (result.hasExpression()) {
++ stream << colourImpl->guardColour( Colour::OriginalExpression )
++ << " " << result.getExpressionInMacro() << '\n';
++ }
++ }
++ void printReconstructedExpression() const {
++ if (result.hasExpandedExpression()) {
++ stream << "with expansion:\n";
++ stream << colourImpl->guardColour( Colour::ReconstructedExpression )
++ << TextFlow::Column( result.getExpandedExpression() )
++ .indent( 2 )
++ << '\n';
++ }
++ }
++ void printMessage() const {
++ if (!messageLabel.empty())
++ stream << messageLabel << ':' << '\n';
++ for (auto const& msg : messages) {
++ // If this assertion is a warning ignore any INFO messages
++ if (printInfoMessages || msg.type != ResultWas::Info)
++ stream << TextFlow::Column(msg.message).indent(2) << '\n';
++ }
++ }
++ void printSourceInfo() const {
++ stream << colourImpl->guardColour( Colour::FileName )
++ << result.getSourceInfo() << ": ";
++ }
++
++ std::ostream& stream;
++ AssertionStats const& stats;
++ AssertionResult const& result;
++ Colour::Code colour;
++ StringRef passOrFail;
++ StringRef messageLabel;
++ std::vector<MessageInfo> const& messages;
++ ColourImpl* colourImpl;
++ bool printInfoMessages;
++};
++
++std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
++ const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
++ return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
++}
++
++std::size_t&
++findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
++ if (i > j && i > k && i > l)
++ return i;
++ else if (j > k && j > l)
++ return j;
++ else if (k > l)
++ return k;
++ else
++ return l;
++}
++
++struct ColumnBreak {};
++struct RowBreak {};
++struct OutputFlush {};
++
++class Duration {
++ enum class Unit {
++ Auto,
++ Nanoseconds,
++ Microseconds,
++ Milliseconds,
++ Seconds,
++ Minutes
++ };
++ static const uint64_t s_nanosecondsInAMicrosecond = 1000;
++ static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
++ static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
++ static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
++
++ double m_inNanoseconds;
++ Unit m_units;
++
++public:
++ explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
++ : m_inNanoseconds(inNanoseconds),
++ m_units(units) {
++ if (m_units == Unit::Auto) {
++ if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
++ m_units = Unit::Nanoseconds;
++ else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
++ m_units = Unit::Microseconds;
++ else if (m_inNanoseconds < s_nanosecondsInASecond)
++ m_units = Unit::Milliseconds;
++ else if (m_inNanoseconds < s_nanosecondsInAMinute)
++ m_units = Unit::Seconds;
++ else
++ m_units = Unit::Minutes;
++ }
++
++ }
++
++ auto value() const -> double {
++ switch (m_units) {
++ case Unit::Microseconds:
++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
++ case Unit::Milliseconds:
++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
++ case Unit::Seconds:
++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
++ case Unit::Minutes:
++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
++ default:
++ return m_inNanoseconds;
++ }
++ }
++ StringRef unitsAsString() const {
++ switch (m_units) {
++ case Unit::Nanoseconds:
++ return "ns"_sr;
++ case Unit::Microseconds:
++ return "us"_sr;
++ case Unit::Milliseconds:
++ return "ms"_sr;
++ case Unit::Seconds:
++ return "s"_sr;
++ case Unit::Minutes:
++ return "m"_sr;
++ default:
++ return "** internal error **"_sr;
++ }
++
++ }
++ friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
++ return os << duration.value() << ' ' << duration.unitsAsString();
++ }
++};
++} // end anon namespace
++
++enum class Justification { Left, Right };
++
++struct ColumnInfo {
++ std::string name;
++ std::size_t width;
++ Justification justification;
++};
++
++class TablePrinter {
++ std::ostream& m_os;
++ std::vector<ColumnInfo> m_columnInfos;
++ ReusableStringStream m_oss;
++ int m_currentColumn = -1;
++ bool m_isOpen = false;
++
++public:
++ TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
++ : m_os( os ),
++ m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
++
++ auto columnInfos() const -> std::vector<ColumnInfo> const& {
++ return m_columnInfos;
++ }
++
++ void open() {
++ if (!m_isOpen) {
++ m_isOpen = true;
++ *this << RowBreak();
++
++ TextFlow::Columns headerCols;
++ for (auto const& info : m_columnInfos) {
++ assert(info.width > 2);
++ headerCols += TextFlow::Column(info.name).width(info.width - 2);
++ headerCols += TextFlow::Spacer( 2 );
++ }
++ m_os << headerCols << '\n';
++
++ m_os << lineOfChars('-') << '\n';
++ }
++ }
++ void close() {
++ if (m_isOpen) {
++ *this << RowBreak();
++ m_os << '\n' << std::flush;
++ m_isOpen = false;
++ }
++ }
++
++ template<typename T>
++ friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
++ tp.m_oss << value;
++ return tp;
++ }
++
++ friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
++ auto colStr = tp.m_oss.str();
++ const auto strSize = colStr.size();
++ tp.m_oss.str("");
++ tp.open();
++ if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
++ tp.m_currentColumn = -1;
++ tp.m_os << '\n';
++ }
++ tp.m_currentColumn++;
++
++ auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
++ auto padding = (strSize + 1 < colInfo.width)
++ ? std::string(colInfo.width - (strSize + 1), ' ')
++ : std::string();
++ if (colInfo.justification == Justification::Left)
++ tp.m_os << colStr << padding << ' ';
++ else
++ tp.m_os << padding << colStr << ' ';
++ return tp;
++ }
++
++ friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
++ if (tp.m_currentColumn > 0) {
++ tp.m_os << '\n';
++ tp.m_currentColumn = -1;
++ }
++ return tp;
++ }
++
++ friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
++ tp.m_os << std::flush;
++ return tp;
++ }
++};
++
++ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
++ StreamingReporterBase( CATCH_MOVE( config ) ),
++ m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
++ [&config]() -> std::vector<ColumnInfo> {
++ if (config.fullConfig()->benchmarkNoAnalysis())
++ {
++ return{
++ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
++ { " samples", 14, Justification::Right },
++ { " iterations", 14, Justification::Right },
++ { " mean", 14, Justification::Right }
++ };
++ }
++ else
++ {
++ return{
++ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
++ { "samples mean std dev", 14, Justification::Right },
++ { "iterations low mean low std dev", 14, Justification::Right },
++ { "est run time high mean high std dev", 14, Justification::Right }
++ };
++ }
++ }())) {}
++ConsoleReporter::~ConsoleReporter() = default;
++
++std::string ConsoleReporter::getDescription() {
++ return "Reports test results as plain lines of text";
++}
++
++void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
++ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
++}
++
++void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
++ m_stream << "Invalid Filter: " << arg << '\n';
++}
++
++void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
++
++void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
++ AssertionResult const& result = _assertionStats.assertionResult;
++
++ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
++
++ // Drop out if result was successful but we're not printing them.
++ // TODO: Make configurable whether skips should be printed
++ if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
++ return;
++
++ lazyPrint();
++
++ ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
++ printer.print();
++ m_stream << '\n' << std::flush;
++}
++
++void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
++ m_tablePrinter->close();
++ m_headerPrinted = false;
++ StreamingReporterBase::sectionStarting(_sectionInfo);
++}
++void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
++ m_tablePrinter->close();
++ if (_sectionStats.missingAssertions) {
++ lazyPrint();
++ auto guard =
++ m_colour->guardColour( Colour::ResultError ).engage( m_stream );
++ if (m_sectionStack.size() > 1)
++ m_stream << "\nNo assertions in section";
++ else
++ m_stream << "\nNo assertions in test case";
++ m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
++ }
++ double dur = _sectionStats.durationInSeconds;
++ if (shouldShowDuration(*m_config, dur)) {
++ m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
++ }
++ if (m_headerPrinted) {
++ m_headerPrinted = false;
++ }
++ StreamingReporterBase::sectionEnded(_sectionStats);
++}
++
++void ConsoleReporter::benchmarkPreparing( StringRef name ) {
++ lazyPrintWithoutClosingBenchmarkTable();
++
++ auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
++ .width( m_tablePrinter->columnInfos()[0].width - 2 );
++
++ bool firstLine = true;
++ for (auto line : nameCol) {
++ if (!firstLine)
++ (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
++ else
++ firstLine = false;
++
++ (*m_tablePrinter) << line << ColumnBreak();
++ }
++}
++
++void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
++ (*m_tablePrinter) << info.samples << ColumnBreak()
++ << info.iterations << ColumnBreak();
++ if ( !m_config->benchmarkNoAnalysis() ) {
++ ( *m_tablePrinter )
++ << Duration( info.estimatedDuration ) << ColumnBreak();
++ }
++ ( *m_tablePrinter ) << OutputFlush{};
++}
++void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
++ if (m_config->benchmarkNoAnalysis())
++ {
++ (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
++ }
++ else
++ {
++ (*m_tablePrinter) << ColumnBreak()
++ << Duration(stats.mean.point.count()) << ColumnBreak()
++ << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
++ << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
++ << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
++ << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
++ << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
++ }
++}
++
++void ConsoleReporter::benchmarkFailed( StringRef error ) {
++ auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
++ (*m_tablePrinter)
++ << "Benchmark failed (" << error << ')'
++ << ColumnBreak() << RowBreak();
++}
++
++void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
++ m_tablePrinter->close();
++ StreamingReporterBase::testCaseEnded(_testCaseStats);
++ m_headerPrinted = false;
++}
++void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
++ printTotalsDivider(_testRunStats.totals);
++ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
++ m_stream << '\n' << std::flush;
++ StreamingReporterBase::testRunEnded(_testRunStats);
++}
++void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
++ StreamingReporterBase::testRunStarting(_testRunInfo);
++ if ( m_config->testSpec().hasFilters() ) {
++ m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
++ << m_config->testSpec() << '\n';
++ }
++ m_stream << "Randomness seeded to: " << getSeed() << '\n';
++}
++
++void ConsoleReporter::lazyPrint() {
++
++ m_tablePrinter->close();
++ lazyPrintWithoutClosingBenchmarkTable();
++}
++
++void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
++
++ if ( !m_testRunInfoPrinted ) {
++ lazyPrintRunInfo();
++ }
++ if (!m_headerPrinted) {
++ printTestCaseAndSectionHeader();
++ m_headerPrinted = true;
++ }
++}
++void ConsoleReporter::lazyPrintRunInfo() {
++ m_stream << '\n'
++ << lineOfChars( '~' ) << '\n'
++ << m_colour->guardColour( Colour::SecondaryText )
++ << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
++ << " host application.\n"
++ << "Run with -? for options\n\n";
++
++ m_testRunInfoPrinted = true;
++}
++void ConsoleReporter::printTestCaseAndSectionHeader() {
++ assert(!m_sectionStack.empty());
++ printOpenHeader(currentTestCaseInfo->name);
++
++ if (m_sectionStack.size() > 1) {
++ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
++
++ auto
++ it = m_sectionStack.begin() + 1, // Skip first section (test case)
++ itEnd = m_sectionStack.end();
++ for (; it != itEnd; ++it)
++ printHeaderString(it->name, 2);
++ }
++
++ SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
++
++
++ m_stream << lineOfChars( '-' ) << '\n'
++ << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
++ << lineOfChars( '.' ) << "\n\n"
++ << std::flush;
++}
++
++void ConsoleReporter::printClosedHeader(std::string const& _name) {
++ printOpenHeader(_name);
++ m_stream << lineOfChars('.') << '\n';
++}
++void ConsoleReporter::printOpenHeader(std::string const& _name) {
++ m_stream << lineOfChars('-') << '\n';
++ {
++ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
++ printHeaderString(_name);
++ }
++}
++
++void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
++ // We want to get a bit fancy with line breaking here, so that subsequent
++ // lines start after ":" if one is present, e.g.
++ // ```
++ // blablabla: Fancy
++ // linebreaking
++ // ```
++ // but we also want to avoid problems with overly long indentation causing
++ // the text to take up too many lines, e.g.
++ // ```
++ // blablabla: F
++ // a
++ // n
++ // c
++ // y
++ // .
++ // .
++ // .
++ // ```
++ // So we limit the prefix indentation check to first quarter of the possible
++ // width
++ std::size_t idx = _string.find( ": " );
++ if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
++ idx += 2;
++ } else {
++ idx = 0;
++ }
++ m_stream << TextFlow::Column( _string )
++ .indent( indent + idx )
++ .initialIndent( indent )
++ << '\n';
++}
++
++void ConsoleReporter::printTotalsDivider(Totals const& totals) {
++ if (totals.testCases.total() > 0) {
++ std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
++ std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
++ std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
++ std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
++ while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
++ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
++ while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
++ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
++
++ m_stream << m_colour->guardColour( Colour::Error )
++ << std::string( failedRatio, '=' )
++ << m_colour->guardColour( Colour::ResultExpectedFailure )
++ << std::string( failedButOkRatio, '=' );
++ if ( totals.testCases.allPassed() ) {
++ m_stream << m_colour->guardColour( Colour::ResultSuccess )
++ << std::string( passedRatio, '=' );
++ } else {
++ m_stream << m_colour->guardColour( Colour::Success )
++ << std::string( passedRatio, '=' );
++ }
++ m_stream << m_colour->guardColour( Colour::Skip )
++ << std::string( skippedRatio, '=' );
++ } else {
++ m_stream << m_colour->guardColour( Colour::Warning )
++ << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
++ }
++ m_stream << '\n';
++}
++
++} // end namespace Catch
++
++#if defined(_MSC_VER)
++#pragma warning(pop)
++#endif
++
++#if defined(__clang__)
++# pragma clang diagnostic pop
++#endif
++
++
++
++
++#include <algorithm>
++#include <cassert>
++
++namespace Catch {
++ namespace {
++ struct BySectionInfo {
++ BySectionInfo( SectionInfo const& other ): m_other( other ) {}
++ BySectionInfo( BySectionInfo const& other ) = default;
++ bool operator()(
++ Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
++ node ) const {
++ return (
++ ( node->stats.sectionInfo.name == m_other.name ) &&
++ ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
++ }
++ void operator=( BySectionInfo const& ) = delete;
++
++ private:
++ SectionInfo const& m_other;
++ };
++
++ } // namespace
++
++ namespace Detail {
++ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
++ AssertionStats const& assertion ):
++ m_assertion( assertion ) {}
++
++ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
++ BenchmarkStats<> const& benchmark ):
++ m_benchmark( benchmark ) {}
++
++ bool AssertionOrBenchmarkResult::isAssertion() const {
++ return m_assertion.some();
++ }
++ bool AssertionOrBenchmarkResult::isBenchmark() const {
++ return m_benchmark.some();
++ }
++
++ AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
++ assert(m_assertion.some());
++
++ return *m_assertion;
++ }
++ BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
++ assert(m_benchmark.some());
++
++ return *m_benchmark;
++ }
++
++ }
++
++ CumulativeReporterBase::~CumulativeReporterBase() = default;
++
++ void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
++ m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
++ }
++
++ void
++ CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
++ // We need a copy, because SectionStats expect to take ownership
++ SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
++ SectionNode* node;
++ if ( m_sectionStack.empty() ) {
++ if ( !m_rootSection ) {
++ m_rootSection =
++ Detail::make_unique<SectionNode>( incompleteStats );
++ }
++ node = m_rootSection.get();
++ } else {
++ SectionNode& parentNode = *m_sectionStack.back();
++ auto it = std::find_if( parentNode.childSections.begin(),
++ parentNode.childSections.end(),
++ BySectionInfo( sectionInfo ) );
++ if ( it == parentNode.childSections.end() ) {
++ auto newNode =
++ Detail::make_unique<SectionNode>( incompleteStats );
++ node = newNode.get();
++ parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
++ } else {
++ node = it->get();
++ }
++ }
++
++ m_deepestSection = node;
++ m_sectionStack.push_back( node );
++ }
++
++ void CumulativeReporterBase::assertionEnded(
++ AssertionStats const& assertionStats ) {
++ assert( !m_sectionStack.empty() );
++ // AssertionResult holds a pointer to a temporary DecomposedExpression,
++ // which getExpandedExpression() calls to build the expression string.
++ // Our section stack copy of the assertionResult will likely outlive the
++ // temporary, so it must be expanded or discarded now to avoid calling
++ // a destroyed object later.
++ if ( m_shouldStoreFailedAssertions &&
++ !assertionStats.assertionResult.isOk() ) {
++ static_cast<void>(
++ assertionStats.assertionResult.getExpandedExpression() );
++ }
++ if ( m_shouldStoreSuccesfulAssertions &&
++ assertionStats.assertionResult.isOk() ) {
++ static_cast<void>(
++ assertionStats.assertionResult.getExpandedExpression() );
++ }
++ SectionNode& sectionNode = *m_sectionStack.back();
++ sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
++ }
++
++ void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
++ assert( !m_sectionStack.empty() );
++ SectionNode& node = *m_sectionStack.back();
++ node.stats = sectionStats;
++ m_sectionStack.pop_back();
++ }
++
++ void CumulativeReporterBase::testCaseEnded(
++ TestCaseStats const& testCaseStats ) {
++ auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
++ assert( m_sectionStack.size() == 0 );
++ node->children.push_back( CATCH_MOVE(m_rootSection) );
++ m_testCases.push_back( CATCH_MOVE(node) );
++
++ assert( m_deepestSection );
++ m_deepestSection->stdOut = testCaseStats.stdOut;
++ m_deepestSection->stdErr = testCaseStats.stdErr;
++ }
++
++
++ void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
++ assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
++ m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
++ m_testRun->children.swap( m_testCases );
++ testRunEndedCumulative();
++ }
++
++ bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
++ return std::any_of(
++ assertionsAndBenchmarks.begin(),
++ assertionsAndBenchmarks.end(),
++ []( Detail::AssertionOrBenchmarkResult const& res ) {
++ return res.isAssertion();
++ } );
++ }
++
++} // end namespace Catch
++
++
++
++
++namespace Catch {
++
++ void EventListenerBase::fatalErrorEncountered( StringRef ) {}
++
++ void EventListenerBase::benchmarkPreparing( StringRef ) {}
++ void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
++ void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
++ void EventListenerBase::benchmarkFailed( StringRef ) {}
++
++ void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
++
++ void EventListenerBase::assertionEnded( AssertionStats const& ) {}
++ void EventListenerBase::listReporters(
++ std::vector<ReporterDescription> const& ) {}
++ void EventListenerBase::listListeners(
++ std::vector<ListenerDescription> const& ) {}
++ void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
++ void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
++ void EventListenerBase::noMatchingTestCases( StringRef ) {}
++ void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
++ void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
++ void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
++ void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
++ void EventListenerBase::sectionStarting( SectionInfo const& ) {}
++ void EventListenerBase::sectionEnded( SectionStats const& ) {}
++ void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
++ void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
++ void EventListenerBase::testRunEnded( TestRunStats const& ) {}
++ void EventListenerBase::skipTest( TestCaseInfo const& ) {}
++} // namespace Catch
++
++
++
++
++#include <algorithm>
++#include <cfloat>
++#include <cstdio>
++#include <ostream>
++#include <iomanip>
++
++namespace Catch {
++
++ namespace {
++ void listTestNamesOnly(std::ostream& out,
++ std::vector<TestCaseHandle> const& tests) {
++ for (auto const& test : tests) {
++ auto const& testCaseInfo = test.getTestCaseInfo();
++
++ if (startsWith(testCaseInfo.name, '#')) {
++ out << '"' << testCaseInfo.name << '"';
++ } else {
++ out << testCaseInfo.name;
++ }
++
++ out << '\n';
++ }
++ out << std::flush;
++ }
++ } // end unnamed namespace
++
++
++ // Because formatting using c++ streams is stateful, drop down to C is
++ // required Alternatively we could use stringstream, but its performance
++ // is... not good.
++ std::string getFormattedDuration( double duration ) {
++ // Max exponent + 1 is required to represent the whole part
++ // + 1 for decimal point
++ // + 3 for the 3 decimal places
++ // + 1 for null terminator
++ const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
++ char buffer[maxDoubleSize];
++
++ // Save previous errno, to prevent sprintf from overwriting it
++ ErrnoGuard guard;
++#ifdef _MSC_VER
++ size_t printedLength = static_cast<size_t>(
++ sprintf_s( buffer, "%.3f", duration ) );
++#else
++ size_t printedLength = static_cast<size_t>(
++ std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
++#endif
++ return std::string( buffer, printedLength );
++ }
++
++ bool shouldShowDuration( IConfig const& config, double duration ) {
++ if ( config.showDurations() == ShowDurations::Always ) {
++ return true;
++ }
++ if ( config.showDurations() == ShowDurations::Never ) {
++ return false;
++ }
++ const double min = config.minDuration();
++ return min >= 0 && duration >= min;
++ }
++
++ std::string serializeFilters( std::vector<std::string> const& filters ) {
++ // We add a ' ' separator between each filter
++ size_t serialized_size = filters.size() - 1;
++ for (auto const& filter : filters) {
++ serialized_size += filter.size();
++ }
++
++ std::string serialized;
++ serialized.reserve(serialized_size);
++ bool first = true;
++
++ for (auto const& filter : filters) {
++ if (!first) {
++ serialized.push_back(' ');
++ }
++ first = false;
++ serialized.append(filter);
++ }
++
++ return serialized;
++ }
++
++ std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
++ for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
++ out.put( value.c );
++ }
++ return out;
++ }
++
++ void
++ defaultListReporters( std::ostream& out,
++ std::vector<ReporterDescription> const& descriptions,
++ Verbosity verbosity ) {
++ out << "Available reporters:\n";
++ const auto maxNameLen =
++ std::max_element( descriptions.begin(),
++ descriptions.end(),
++ []( ReporterDescription const& lhs,
++ ReporterDescription const& rhs ) {
++ return lhs.name.size() < rhs.name.size();
++ } )
++ ->name.size();
++
++ for ( auto const& desc : descriptions ) {
++ if ( verbosity == Verbosity::Quiet ) {
++ out << TextFlow::Column( desc.name )
++ .indent( 2 )
++ .width( 5 + maxNameLen )
++ << '\n';
++ } else {
++ out << TextFlow::Column( desc.name + ':' )
++ .indent( 2 )
++ .width( 5 + maxNameLen ) +
++ TextFlow::Column( desc.description )
++ .initialIndent( 0 )
++ .indent( 2 )
++ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
++ << '\n';
++ }
++ }
++ out << '\n' << std::flush;
++ }
++
++ void defaultListListeners( std::ostream& out,
++ std::vector<ListenerDescription> const& descriptions ) {
++ out << "Registered listeners:\n";
++
++ if(descriptions.empty()) {
++ return;
++ }
++
++ const auto maxNameLen =
++ std::max_element( descriptions.begin(),
++ descriptions.end(),
++ []( ListenerDescription const& lhs,
++ ListenerDescription const& rhs ) {
++ return lhs.name.size() < rhs.name.size();
++ } )
++ ->name.size();
++
++ for ( auto const& desc : descriptions ) {
++ out << TextFlow::Column( static_cast<std::string>( desc.name ) +
++ ':' )
++ .indent( 2 )
++ .width( maxNameLen + 5 ) +
++ TextFlow::Column( desc.description )
++ .initialIndent( 0 )
++ .indent( 2 )
++ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
++ << '\n';
++ }
++
++ out << '\n' << std::flush;
++ }
++
++ void defaultListTags( std::ostream& out,
++ std::vector<TagInfo> const& tags,
++ bool isFiltered ) {
++ if ( isFiltered ) {
++ out << "Tags for matching test cases:\n";
++ } else {
++ out << "All available tags:\n";
++ }
++
++ for ( auto const& tagCount : tags ) {
++ ReusableStringStream rss;
++ rss << " " << std::setw( 2 ) << tagCount.count << " ";
++ auto str = rss.str();
++ auto wrapper = TextFlow::Column( tagCount.all() )
++ .initialIndent( 0 )
++ .indent( str.size() )
++ .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
++ out << str << wrapper << '\n';
++ }
++ out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
++ }
++
++ void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
++ // We special case this to provide the equivalent of old
++ // `--list-test-names-only`, which could then be used by the
++ // `--input-file` option.
++ if (verbosity == Verbosity::Quiet) {
++ listTestNamesOnly(out, tests);
++ return;
++ }
++
++ if (isFiltered) {
++ out << "Matching test cases:\n";
++ } else {
++ out << "All available test cases:\n";
++ }
++
++ for (auto const& test : tests) {
++ auto const& testCaseInfo = test.getTestCaseInfo();
++ Colour::Code colour = testCaseInfo.isHidden()
++ ? Colour::SecondaryText
++ : Colour::None;
++ auto colourGuard = streamColour->guardColour( colour ).engage( out );
++
++ out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
++ if (verbosity >= Verbosity::High) {
++ out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
++ }
++ if (!testCaseInfo.tags.empty() &&
++ verbosity > Verbosity::Quiet) {
++ out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
++ }
++ }
++
++ if (isFiltered) {
++ out << pluralise(tests.size(), "matching test case"_sr);
++ } else {
++ out << pluralise(tests.size(), "test case"_sr);
++ }
++ out << "\n\n" << std::flush;
++ }
++
++ namespace {
++ class SummaryColumn {
++ public:
++ SummaryColumn( std::string suffix, Colour::Code colour ):
++ m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
++
++ SummaryColumn&& addRow( std::uint64_t count ) && {
++ std::string row = std::to_string(count);
++ auto const new_width = std::max( m_width, row.size() );
++ if ( new_width > m_width ) {
++ for ( auto& oldRow : m_rows ) {
++ oldRow.insert( 0, new_width - m_width, ' ' );
++ }
++ } else {
++ row.insert( 0, m_width - row.size(), ' ' );
++ }
++ m_width = new_width;
++ m_rows.push_back( row );
++ return std::move( *this );
++ }
++
++ std::string const& getSuffix() const { return m_suffix; }
++ Colour::Code getColour() const { return m_colour; }
++ std::string const& getRow( std::size_t index ) const {
++ return m_rows[index];
++ }
++
++ private:
++ std::string m_suffix;
++ Colour::Code m_colour;
++ std::size_t m_width = 0;
++ std::vector<std::string> m_rows;
++ };
++
++ void printSummaryRow( std::ostream& stream,
++ ColourImpl& colour,
++ StringRef label,
++ std::vector<SummaryColumn> const& cols,
++ std::size_t row ) {
++ for ( auto const& col : cols ) {
++ auto const& value = col.getRow( row );
++ auto const& suffix = col.getSuffix();
++ if ( suffix.empty() ) {
++ stream << label << ": ";
++ if ( value != "0" ) {
++ stream << value;
++ } else {
++ stream << colour.guardColour( Colour::Warning )
++ << "- none -";
++ }
++ } else if ( value != "0" ) {
++ stream << colour.guardColour( Colour::LightGrey ) << " | "
++ << colour.guardColour( col.getColour() ) << value
++ << ' ' << suffix;
++ }
++ }
++ stream << '\n';
++ }
++ } // namespace
++
++ void printTestRunTotals( std::ostream& stream,
++ ColourImpl& streamColour,
++ Totals const& totals ) {
++ if ( totals.testCases.total() == 0 ) {
++ stream << streamColour.guardColour( Colour::Warning )
++ << "No tests ran\n";
++ return;
++ }
++
++ if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
++ stream << streamColour.guardColour( Colour::ResultSuccess )
++ << "All tests passed";
++ stream << " ("
++ << pluralise( totals.assertions.passed, "assertion"_sr )
++ << " in "
++ << pluralise( totals.testCases.passed, "test case"_sr )
++ << ')' << '\n';
++ return;
++ }
++
++ std::vector<SummaryColumn> columns;
++ // Don't include "skipped assertions" in total count
++ const auto totalAssertionCount =
++ totals.assertions.total() - totals.assertions.skipped;
++ columns.push_back( SummaryColumn( "", Colour::None )
++ .addRow( totals.testCases.total() )
++ .addRow( totalAssertionCount ) );
++ columns.push_back( SummaryColumn( "passed", Colour::Success )
++ .addRow( totals.testCases.passed )
++ .addRow( totals.assertions.passed ) );
++ columns.push_back( SummaryColumn( "failed", Colour::ResultError )
++ .addRow( totals.testCases.failed )
++ .addRow( totals.assertions.failed ) );
++ columns.push_back( SummaryColumn( "skipped", Colour::Skip )
++ .addRow( totals.testCases.skipped )
++ // Don't print "skipped assertions"
++ .addRow( 0 ) );
++ columns.push_back(
++ SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
++ .addRow( totals.testCases.failedButOk )
++ .addRow( totals.assertions.failedButOk ) );
++ printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
++ printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
++ }
++
++} // namespace Catch
++
++
++//
++
++namespace Catch {
++ namespace {
++ void writeSourceInfo( JsonObjectWriter& writer,
++ SourceLineInfo const& sourceInfo ) {
++ auto source_location_writer =
++ writer.write( "source-location"_sr ).writeObject();
++ source_location_writer.write( "filename"_sr )
++ .write( sourceInfo.file );
++ source_location_writer.write( "line"_sr ).write( sourceInfo.line );
++ }
++
++ void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
++ for ( auto const& tag : tags ) {
++ writer.write( tag.original );
++ }
++ }
++
++ void writeProperties( JsonArrayWriter writer,
++ TestCaseInfo const& info ) {
++ if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
++ if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
++ if ( info.expectedToFail() ) {
++ writer.write( "expected-to-fail"_sr );
++ }
++ if ( info.throws() ) { writer.write( "throws"_sr ); }
++ }
++
++ } // namespace
++
++ JsonReporter::JsonReporter( ReporterConfig&& config ):
++ StreamingReporterBase{ CATCH_MOVE( config ) } {
++
++ m_preferences.shouldRedirectStdOut = true;
++ // TBD: Do we want to report all assertions? XML reporter does
++ // not, but for machine-parseable reporters I think the answer
++ // should be yes.
++ m_preferences.shouldReportAllAssertions = true;
++
++ m_objectWriters.emplace( m_stream );
++ m_writers.emplace( Writer::Object );
++ auto& writer = m_objectWriters.top();
++
++ writer.write( "version"_sr ).write( 1 );
++
++ {
++ auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
++ metadata_writer.write( "name"_sr ).write( m_config->name() );
++ metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
++ metadata_writer.write( "catch2-version"_sr )
++ .write( libraryVersion() );
++ if ( m_config->testSpec().hasFilters() ) {
++ metadata_writer.write( "filters"_sr )
++ .write( m_config->testSpec() );
++ }
++ }
++ }
++
++ JsonReporter::~JsonReporter() {
++ endListing();
++ // TODO: Ensure this closes the top level object, add asserts
++ assert( m_writers.size() == 1 && "Only the top level object should be open" );
++ assert( m_writers.top() == Writer::Object );
++ endObject();
++ m_stream << '\n' << std::flush;
++ assert( m_writers.empty() );
++ }
++
++ JsonArrayWriter& JsonReporter::startArray() {
++ m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
++ m_writers.emplace( Writer::Array );
++ return m_arrayWriters.top();
++ }
++ JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
++ m_arrayWriters.emplace(
++ m_objectWriters.top().write( key ).writeArray() );
++ m_writers.emplace( Writer::Array );
++ return m_arrayWriters.top();
++ }
++
++ JsonObjectWriter& JsonReporter::startObject() {
++ m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
++ m_writers.emplace( Writer::Object );
++ return m_objectWriters.top();
++ }
++ JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
++ m_objectWriters.emplace(
++ m_objectWriters.top().write( key ).writeObject() );
++ m_writers.emplace( Writer::Object );
++ return m_objectWriters.top();
++ }
++
++ void JsonReporter::endObject() {
++ assert( isInside( Writer::Object ) );
++ m_objectWriters.pop();
++ m_writers.pop();
++ }
++ void JsonReporter::endArray() {
++ assert( isInside( Writer::Array ) );
++ m_arrayWriters.pop();
++ m_writers.pop();
++ }
++
++ bool JsonReporter::isInside( Writer writer ) {
++ return !m_writers.empty() && m_writers.top() == writer;
++ }
++
++ void JsonReporter::startListing() {
++ if ( !m_startedListing ) { startObject( "listings"_sr ); }
++ m_startedListing = true;
++ }
++ void JsonReporter::endListing() {
++ if ( m_startedListing ) { endObject(); }
++ m_startedListing = false;
++ }
++
++ std::string JsonReporter::getDescription() {
++ return "Outputs listings as JSON. Test listing is Work-in-Progress!";
++ }
++
++ void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
++ StreamingReporterBase::testRunStarting( runInfo );
++ endListing();
++
++ assert( isInside( Writer::Object ) );
++ startObject( "test-run"_sr );
++ startArray( "test-cases"_sr );
++ }
++
++ static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
++ writer.write( "passed"_sr ).write( counts.passed );
++ writer.write( "failed"_sr ).write( counts.failed );
++ writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
++ writer.write( "skipped"_sr ).write( counts.skipped );
++ }
++
++ void JsonReporter::testRunEnded(TestRunStats const& runStats) {
++ assert( isInside( Writer::Array ) );
++ // End "test-cases"
++ endArray();
++
++ {
++ auto totals =
++ m_objectWriters.top().write( "totals"_sr ).writeObject();
++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
++ runStats.totals.assertions );
++ writeCounts( totals.write( "test-cases"_sr ).writeObject(),
++ runStats.totals.testCases );
++ }
++
++ // End the "test-run" object
++ endObject();
++ }
++
++ void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
++ StreamingReporterBase::testCaseStarting( tcInfo );
++
++ assert( isInside( Writer::Array ) &&
++ "We should be in the 'test-cases' array" );
++ startObject();
++ // "test-info" prelude
++ {
++ auto testInfo =
++ m_objectWriters.top().write( "test-info"_sr ).writeObject();
++ // TODO: handle testName vs className!!
++ testInfo.write( "name"_sr ).write( tcInfo.name );
++ writeSourceInfo(testInfo, tcInfo.lineInfo);
++ writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
++ writeProperties( testInfo.write( "properties"_sr ).writeArray(),
++ tcInfo );
++ }
++
++
++ // Start the array for individual test runs (testCasePartial pairs)
++ startArray( "runs"_sr );
++ }
++
++ void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
++ StreamingReporterBase::testCaseEnded( tcStats );
++
++ // We need to close the 'runs' array before finishing the test case
++ assert( isInside( Writer::Array ) );
++ endArray();
++
++ {
++ auto totals =
++ m_objectWriters.top().write( "totals"_sr ).writeObject();
++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
++ tcStats.totals.assertions );
++ // We do not write the test case totals, because there will always be just one test case here.
++ // TODO: overall "result" -> success, skip, fail here? Or in partial result?
++ }
++ // We do not write out stderr/stdout, because we instead wrote those out in partial runs
++
++ // TODO: aborting?
++
++ // And we also close this test case's object
++ assert( isInside( Writer::Object ) );
++ endObject();
++ }
++
++ void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
++ uint64_t index ) {
++ startObject();
++ m_objectWriters.top().write( "run-idx"_sr ).write( index );
++ startArray( "path"_sr );
++ // TODO: we want to delay most of the printing to the 'root' section
++ // TODO: childSection key name?
++ }
++
++ void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
++ uint64_t /*index*/ ) {
++ // Fixme: the top level section handles this.
++ //// path object
++ endArray();
++ if ( !tcStats.stdOut.empty() ) {
++ m_objectWriters.top()
++ .write( "captured-stdout"_sr )
++ .write( tcStats.stdOut );
++ }
++ if ( !tcStats.stdErr.empty() ) {
++ m_objectWriters.top()
++ .write( "captured-stderr"_sr )
++ .write( tcStats.stdErr );
++ }
++ {
++ auto totals =
++ m_objectWriters.top().write( "totals"_sr ).writeObject();
++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
++ tcStats.totals.assertions );
++ // We do not write the test case totals, because there will
++ // always be just one test case here.
++ // TODO: overall "result" -> success, skip, fail here? Or in
++ // partial result?
++ }
++ // TODO: aborting?
++ // run object
++ endObject();
++ }
++
++ void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
++ assert( isInside( Writer::Array ) &&
++ "Section should always start inside an object" );
++ // We want to nest top level sections, even though it shares name
++ // and source loc with the TEST_CASE
++ auto& sectionObject = startObject();
++ sectionObject.write( "kind"_sr ).write( "section"_sr );
++ sectionObject.write( "name"_sr ).write( sectionInfo.name );
++ writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
++
++
++ // TBD: Do we want to create this event lazily? It would become
++ // rather complex, but we could do it, and it would look
++ // better for empty sections. OTOH, empty sections should
++ // be rare.
++ startArray( "path"_sr );
++ }
++ void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
++ // End the subpath array
++ endArray();
++ // TODO: metadata
++ // TODO: what info do we have here?
++
++ // End the section object
++ endObject();
++ }
++
++ void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {}
++ void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
++ // TODO: There is lot of different things to handle here, but
++ // we can fill it in later, after we show that the basic
++ // outline and streaming reporter impl works well enough.
++ //if ( !m_config->includeSuccessfulResults()
++ // && assertionStats.assertionResult.isOk() ) {
++ // return;
++ //}
++ assert( isInside( Writer::Array ) );
++ auto assertionObject = m_arrayWriters.top().writeObject();
++
++ assertionObject.write( "kind"_sr ).write( "assertion"_sr );
++ writeSourceInfo( assertionObject,
++ assertionStats.assertionResult.getSourceInfo() );
++ assertionObject.write( "status"_sr )
++ .write( assertionStats.assertionResult.isOk() );
++ // TODO: handling of result.
++ // TODO: messages
++ // TODO: totals?
++ }
++
++
++ void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
++ void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
++ void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
++ void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
++
++ void JsonReporter::listReporters(
++ std::vector<ReporterDescription> const& descriptions ) {
++ startListing();
++
++ auto writer =
++ m_objectWriters.top().write( "reporters"_sr ).writeArray();
++ for ( auto const& desc : descriptions ) {
++ auto desc_writer = writer.writeObject();
++ desc_writer.write( "name"_sr ).write( desc.name );
++ desc_writer.write( "description"_sr ).write( desc.description );
++ }
++ }
++ void JsonReporter::listListeners(
++ std::vector<ListenerDescription> const& descriptions ) {
++ startListing();
++
++ auto writer =
++ m_objectWriters.top().write( "listeners"_sr ).writeArray();
++
++ for ( auto const& desc : descriptions ) {
++ auto desc_writer = writer.writeObject();
++ desc_writer.write( "name"_sr ).write( desc.name );
++ desc_writer.write( "description"_sr ).write( desc.description );
++ }
++ }
++ void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
++ startListing();
++
++ auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
++
++ for ( auto const& test : tests ) {
++ auto desc_writer = writer.writeObject();
++ auto const& info = test.getTestCaseInfo();
++
++ desc_writer.write( "name"_sr ).write( info.name );
++ desc_writer.write( "class-name"_sr ).write( info.className );
++ {
++ auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
++ for ( auto const& tag : info.tags ) {
++ tag_writer.write( tag.original );
++ }
++ }
++ writeSourceInfo( desc_writer, info.lineInfo );
++ }
++ }
++ void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
++ startListing();
++
++ auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
++ for ( auto const& tag : tags ) {
++ auto tag_writer = writer.writeObject();
++ {
++ auto aliases_writer =
++ tag_writer.write( "aliases"_sr ).writeArray();
++ for ( auto alias : tag.spellings ) {
++ aliases_writer.write( alias );
++ }
++ }
++ tag_writer.write( "count"_sr ).write( tag.count );
++ }
++ }
++} // namespace Catch
++
++
++
++
++#include <cassert>
++#include <ctime>
++#include <algorithm>
++#include <iomanip>
++
++namespace Catch {
++
++ namespace {
++ std::string getCurrentTimestamp() {
++ time_t rawtime;
++ std::time(&rawtime);
++
++ std::tm timeInfo = {};
++#if defined (_MSC_VER) || defined (__MINGW32__)
++ gmtime_s(&timeInfo, &rawtime);
++#elif defined (CATCH_PLATFORM_PLAYSTATION)
++ gmtime_s(&rawtime, &timeInfo);
++#elif defined (__IAR_SYSTEMS_ICC__)
++ timeInfo = *std::gmtime(&rawtime);
++#else
++ gmtime_r(&rawtime, &timeInfo);
++#endif
++
++ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
++ char timeStamp[timeStampSize];
++ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
++
++ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
++
++ return std::string(timeStamp, timeStampSize - 1);
++ }
++
++ std::string fileNameTag(std::vector<Tag> const& tags) {
++ auto it = std::find_if(begin(tags),
++ end(tags),
++ [] (Tag const& tag) {
++ return tag.original.size() > 0
++ && tag.original[0] == '#'; });
++ if (it != tags.end()) {
++ return static_cast<std::string>(
++ it->original.substr(1, it->original.size() - 1)
++ );
++ }
++ return std::string();
++ }
++
++ // Formats the duration in seconds to 3 decimal places.
++ // This is done because some genius defined Maven Surefire schema
++ // in a way that only accepts 3 decimal places, and tools like
++ // Jenkins use that schema for validation JUnit reporter output.
++ std::string formatDuration( double seconds ) {
++ ReusableStringStream rss;
++ rss << std::fixed << std::setprecision( 3 ) << seconds;
++ return rss.str();
++ }
++
++ static void normalizeNamespaceMarkers(std::string& str) {
++ std::size_t pos = str.find( "::" );
++ while ( pos != std::string::npos ) {
++ str.replace( pos, 2, "." );
++ pos += 1;
++ pos = str.find( "::", pos );
++ }
++ }
++
++ } // anonymous namespace
++
++ JunitReporter::JunitReporter( ReporterConfig&& _config )
++ : CumulativeReporterBase( CATCH_MOVE(_config) ),
++ xml( m_stream )
++ {
++ m_preferences.shouldRedirectStdOut = true;
++ m_preferences.shouldReportAllAssertions = true;
++ m_shouldStoreSuccesfulAssertions = false;
++ }
++
++ std::string JunitReporter::getDescription() {
++ return "Reports test results in an XML format that looks like Ant's junitreport target";
++ }
++
++ void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
++ CumulativeReporterBase::testRunStarting( runInfo );
++ xml.startElement( "testsuites" );
++ suiteTimer.start();
++ stdOutForSuite.clear();
++ stdErrForSuite.clear();
++ unexpectedExceptions = 0;
++ }
++
++ void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
++ m_okToFail = testCaseInfo.okToFail();
++ }
++
++ void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
++ if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
++ unexpectedExceptions++;
++ CumulativeReporterBase::assertionEnded( assertionStats );
++ }
++
++ void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
++ stdOutForSuite += testCaseStats.stdOut;
++ stdErrForSuite += testCaseStats.stdErr;
++ CumulativeReporterBase::testCaseEnded( testCaseStats );
++ }
++
++ void JunitReporter::testRunEndedCumulative() {
++ const auto suiteTime = suiteTimer.getElapsedSeconds();
++ writeRun( *m_testRun, suiteTime );
++ xml.endElement();
++ }
++
++ void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
++ XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
++
++ TestRunStats const& stats = testRunNode.value;
++ xml.writeAttribute( "name"_sr, stats.runInfo.name );
++ xml.writeAttribute( "errors"_sr, unexpectedExceptions );
++ xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
++ xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
++ xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
++ xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
++ if( m_config->showDurations() == ShowDurations::Never )
++ xml.writeAttribute( "time"_sr, ""_sr );
++ else
++ xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
++ xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
++
++ // Write properties
++ {
++ auto properties = xml.scopedElement("properties");
++ xml.scopedElement("property")
++ .writeAttribute("name"_sr, "random-seed"_sr)
++ .writeAttribute("value"_sr, m_config->rngSeed());
++ if (m_config->testSpec().hasFilters()) {
++ xml.scopedElement("property")
++ .writeAttribute("name"_sr, "filters"_sr)
++ .writeAttribute("value"_sr, m_config->testSpec());
++ }
++ }
++
++ // Write test cases
++ for( auto const& child : testRunNode.children )
++ writeTestCase( *child );
++
++ xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
++ xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
++ }
++
++ void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
++ TestCaseStats const& stats = testCaseNode.value;
++
++ // All test cases have exactly one section - which represents the
++ // test case itself. That section may have 0-n nested sections
++ assert( testCaseNode.children.size() == 1 );
++ SectionNode const& rootSection = *testCaseNode.children.front();
++
++ std::string className =
++ static_cast<std::string>( stats.testInfo->className );
++
++ if( className.empty() ) {
++ className = fileNameTag(stats.testInfo->tags);
++ if ( className.empty() ) {
++ className = "global";
++ }
++ }
++
++ if ( !m_config->name().empty() )
++ className = static_cast<std::string>(m_config->name()) + '.' + className;
++
++ normalizeNamespaceMarkers(className);
++
++ writeSection( className, "", rootSection, stats.testInfo->okToFail() );
++ }
++
++ void JunitReporter::writeSection( std::string const& className,
++ std::string const& rootName,
++ SectionNode const& sectionNode,
++ bool testOkToFail) {
++ std::string name = trim( sectionNode.stats.sectionInfo.name );
++ if( !rootName.empty() )
++ name = rootName + '/' + name;
++
++ if( sectionNode.hasAnyAssertions()
++ || !sectionNode.stdOut.empty()
++ || !sectionNode.stdErr.empty() ) {
++ XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
++ if( className.empty() ) {
++ xml.writeAttribute( "classname"_sr, name );
++ xml.writeAttribute( "name"_sr, "root"_sr );
++ }
++ else {
++ xml.writeAttribute( "classname"_sr, className );
++ xml.writeAttribute( "name"_sr, name );
++ }
++ xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
++ // This is not ideal, but it should be enough to mimic gtest's
++ // junit output.
++ // Ideally the JUnit reporter would also handle `skipTest`
++ // events and write those out appropriately.
++ xml.writeAttribute( "status"_sr, "run"_sr );
++
++ if (sectionNode.stats.assertions.failedButOk) {
++ xml.scopedElement("skipped")
++ .writeAttribute("message", "TEST_CASE tagged with !mayfail");
++ }
++
++ writeAssertions( sectionNode );
++
++
++ if( !sectionNode.stdOut.empty() )
++ xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
++ if( !sectionNode.stdErr.empty() )
++ xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
++ }
++ for( auto const& childNode : sectionNode.childSections )
++ if( className.empty() )
++ writeSection( name, "", *childNode, testOkToFail );
++ else
++ writeSection( className, name, *childNode, testOkToFail );
++ }
++
++ void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
++ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
++ if (assertionOrBenchmark.isAssertion()) {
++ writeAssertion(assertionOrBenchmark.asAssertion());
++ }
++ }
++ }
++
++ void JunitReporter::writeAssertion( AssertionStats const& stats ) {
++ AssertionResult const& result = stats.assertionResult;
++ if ( !result.isOk() ||
++ result.getResultType() == ResultWas::ExplicitSkip ) {
++ std::string elementName;
++ switch( result.getResultType() ) {
++ case ResultWas::ThrewException:
++ case ResultWas::FatalErrorCondition:
++ elementName = "error";
++ break;
++ case ResultWas::ExplicitFailure:
++ case ResultWas::ExpressionFailed:
++ case ResultWas::DidntThrowException:
++ elementName = "failure";
++ break;
++ case ResultWas::ExplicitSkip:
++ elementName = "skipped";
++ break;
++ // We should never see these here:
++ case ResultWas::Info:
++ case ResultWas::Warning:
++ case ResultWas::Ok:
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ elementName = "internalError";
++ break;
++ }
++
++ XmlWriter::ScopedElement e = xml.scopedElement( elementName );
++
++ xml.writeAttribute( "message"_sr, result.getExpression() );
++ xml.writeAttribute( "type"_sr, result.getTestMacroName() );
++
++ ReusableStringStream rss;
++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
++ rss << "SKIPPED\n";
++ } else {
++ rss << "FAILED" << ":\n";
++ if (result.hasExpression()) {
++ rss << " ";
++ rss << result.getExpressionInMacro();
++ rss << '\n';
++ }
++ if (result.hasExpandedExpression()) {
++ rss << "with expansion:\n";
++ rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
++ }
++ }
++
++ if( result.hasMessage() )
++ rss << result.getMessage() << '\n';
++ for( auto const& msg : stats.infoMessages )
++ if( msg.type == ResultWas::Info )
++ rss << msg.message << '\n';
++
++ rss << "at " << result.getSourceInfo();
++ xml.writeText( rss.str(), XmlFormatting::Newline );
++ }
++ }
++
++} // end namespace Catch
++
++
++
++
++#include <ostream>
++
++namespace Catch {
++ void MultiReporter::updatePreferences(IEventListener const& reporterish) {
++ m_preferences.shouldRedirectStdOut |=
++ reporterish.getPreferences().shouldRedirectStdOut;
++ m_preferences.shouldReportAllAssertions |=
++ reporterish.getPreferences().shouldReportAllAssertions;
++ }
++
++ void MultiReporter::addListener( IEventListenerPtr&& listener ) {
++ updatePreferences(*listener);
++ m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
++ ++m_insertedListeners;
++ }
++
++ void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
++ updatePreferences(*reporter);
++
++ // We will need to output the captured stdout if there are reporters
++ // that do not want it captured.
++ // We do not consider listeners, because it is generally assumed that
++ // listeners are output-transparent, even though they can ask for stdout
++ // capture to do something with it.
++ m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
++
++ // Reporters can always be placed to the back without breaking the
++ // reporting order
++ m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
++ }
++
++ void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->noMatchingTestCases( unmatchedSpec );
++ }
++ }
++
++ void MultiReporter::fatalErrorEncountered( StringRef error ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->fatalErrorEncountered( error );
++ }
++ }
++
++ void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->reportInvalidTestSpec( arg );
++ }
++ }
++
++ void MultiReporter::benchmarkPreparing( StringRef name ) {
++ for (auto& reporterish : m_reporterLikes) {
++ reporterish->benchmarkPreparing(name);
++ }
++ }
++ void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->benchmarkStarting( benchmarkInfo );
++ }
++ }
++ void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->benchmarkEnded( benchmarkStats );
++ }
++ }
++
++ void MultiReporter::benchmarkFailed( StringRef error ) {
++ for (auto& reporterish : m_reporterLikes) {
++ reporterish->benchmarkFailed(error);
++ }
++ }
++
++ void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testRunStarting( testRunInfo );
++ }
++ }
++
++ void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testCaseStarting( testInfo );
++ }
++ }
++
++ void
++ MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
++ uint64_t partNumber ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testCasePartialStarting( testInfo, partNumber );
++ }
++ }
++
++ void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->sectionStarting( sectionInfo );
++ }
++ }
++
++ void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->assertionStarting( assertionInfo );
++ }
++ }
++
++ void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
++ const bool reportByDefault =
++ assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
++ m_config->includeSuccessfulResults();
++
++ for ( auto & reporterish : m_reporterLikes ) {
++ if ( reportByDefault ||
++ reporterish->getPreferences().shouldReportAllAssertions ) {
++ reporterish->assertionEnded( assertionStats );
++ }
++ }
++ }
++
++ void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->sectionEnded( sectionStats );
++ }
++ }
++
++ void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
++ uint64_t partNumber ) {
++ if ( m_preferences.shouldRedirectStdOut &&
++ m_haveNoncapturingReporters ) {
++ if ( !testStats.stdOut.empty() ) {
++ Catch::cout() << testStats.stdOut << std::flush;
++ }
++ if ( !testStats.stdErr.empty() ) {
++ Catch::cerr() << testStats.stdErr << std::flush;
++ }
++ }
++
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testCasePartialEnded( testStats, partNumber );
++ }
++ }
++
++ void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testCaseEnded( testCaseStats );
++ }
++ }
++
++ void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->testRunEnded( testRunStats );
++ }
++ }
++
++
++ void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->skipTest( testInfo );
++ }
++ }
++
++ void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
++ for (auto& reporterish : m_reporterLikes) {
++ reporterish->listReporters(descriptions);
++ }
++ }
++
++ void MultiReporter::listListeners(
++ std::vector<ListenerDescription> const& descriptions ) {
++ for ( auto& reporterish : m_reporterLikes ) {
++ reporterish->listListeners( descriptions );
++ }
++ }
++
++ void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
++ for (auto& reporterish : m_reporterLikes) {
++ reporterish->listTests(tests);
++ }
++ }
++
++ void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
++ for (auto& reporterish : m_reporterLikes) {
++ reporterish->listTags(tags);
++ }
++ }
++
++} // end namespace Catch
++
++
++
++
++
++namespace Catch {
++ namespace Detail {
++
++ void registerReporterImpl( std::string const& name,
++ IReporterFactoryPtr reporterPtr ) {
++ CATCH_TRY {
++ getMutableRegistryHub().registerReporter(
++ name, CATCH_MOVE( reporterPtr ) );
++ }
++ CATCH_CATCH_ALL {
++ // Do not throw when constructing global objects, instead
++ // register the exception to be processed later
++ getMutableRegistryHub().registerStartupException();
++ }
++ }
++
++ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
++ getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
++ }
++
++
++ } // namespace Detail
++} // namespace Catch
++
++
++
++
++#include <map>
++
++namespace Catch {
++
++ namespace {
++ std::string createMetadataString(IConfig const& config) {
++ ReusableStringStream sstr;
++ if ( config.testSpec().hasFilters() ) {
++ sstr << "filters='"
++ << config.testSpec()
++ << "' ";
++ }
++ sstr << "rng-seed=" << config.rngSeed();
++ return sstr.str();
++ }
++ }
++
++ void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
++ CumulativeReporterBase::testRunStarting(testRunInfo);
++
++ xml.writeComment( createMetadataString( *m_config ) );
++ xml.startElement("testExecutions");
++ xml.writeAttribute("version"_sr, '1');
++ }
++
++ void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
++ std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
++
++ for ( auto const& child : runNode.children ) {
++ testsPerFile[child->value.testInfo->lineInfo.file].push_back(
++ child.get() );
++ }
++
++ for ( auto const& kv : testsPerFile ) {
++ writeTestFile( kv.first, kv.second );
++ }
++ }
++
++ void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
++ XmlWriter::ScopedElement e = xml.scopedElement("file");
++ xml.writeAttribute("path"_sr, filename);
++
++ for (auto const& child : testCaseNodes)
++ writeTestCase(*child);
++ }
++
++ void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
++ // All test cases have exactly one section - which represents the
++ // test case itself. That section may have 0-n nested sections
++ assert(testCaseNode.children.size() == 1);
++ SectionNode const& rootSection = *testCaseNode.children.front();
++ writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
++ }
++
++ void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
++ std::string name = trim(sectionNode.stats.sectionInfo.name);
++ if (!rootName.empty())
++ name = rootName + '/' + name;
++
++ if ( sectionNode.hasAnyAssertions()
++ || !sectionNode.stdOut.empty()
++ || !sectionNode.stdErr.empty() ) {
++ XmlWriter::ScopedElement e = xml.scopedElement("testCase");
++ xml.writeAttribute("name"_sr, name);
++ xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
++
++ writeAssertions(sectionNode, okToFail);
++ }
++
++ for (auto const& childNode : sectionNode.childSections)
++ writeSection(name, *childNode, okToFail);
++ }
++
++ void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
++ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
++ if (assertionOrBenchmark.isAssertion()) {
++ writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
++ }
++ }
++ }
++
++ void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
++ AssertionResult const& result = stats.assertionResult;
++ if ( !result.isOk() ||
++ result.getResultType() == ResultWas::ExplicitSkip ) {
++ std::string elementName;
++ if (okToFail) {
++ elementName = "skipped";
++ } else {
++ switch (result.getResultType()) {
++ case ResultWas::ThrewException:
++ case ResultWas::FatalErrorCondition:
++ elementName = "error";
++ break;
++ case ResultWas::ExplicitFailure:
++ case ResultWas::ExpressionFailed:
++ case ResultWas::DidntThrowException:
++ elementName = "failure";
++ break;
++ case ResultWas::ExplicitSkip:
++ elementName = "skipped";
++ break;
++ // We should never see these here:
++ case ResultWas::Info:
++ case ResultWas::Warning:
++ case ResultWas::Ok:
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ elementName = "internalError";
++ break;
++ }
++ }
++
++ XmlWriter::ScopedElement e = xml.scopedElement(elementName);
++
++ ReusableStringStream messageRss;
++ messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
++ xml.writeAttribute("message"_sr, messageRss.str());
++
++ ReusableStringStream textRss;
++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
++ textRss << "SKIPPED\n";
++ } else {
++ textRss << "FAILED:\n";
++ if (result.hasExpression()) {
++ textRss << '\t' << result.getExpressionInMacro() << '\n';
++ }
++ if (result.hasExpandedExpression()) {
++ textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
++ }
++ }
++
++ if (result.hasMessage())
++ textRss << result.getMessage() << '\n';
++
++ for (auto const& msg : stats.infoMessages)
++ if (msg.type == ResultWas::Info)
++ textRss << msg.message << '\n';
++
++ textRss << "at " << result.getSourceInfo();
++ xml.writeText(textRss.str(), XmlFormatting::Newline);
++ }
++ }
++
++} // end namespace Catch
++
++
++
++namespace Catch {
++
++ StreamingReporterBase::~StreamingReporterBase() = default;
++
++ void
++ StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
++ currentTestRunInfo = _testRunInfo;
++ }
++
++ void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
++ currentTestCaseInfo = nullptr;
++ }
++
++} // end namespace Catch
++
++
++
++#include <algorithm>
++#include <ostream>
++
++namespace Catch {
++
++ namespace {
++ // Yes, this has to be outside the class and namespaced by naming.
++ // Making older compiler happy is hard.
++ static constexpr StringRef tapFailedString = "not ok"_sr;
++ static constexpr StringRef tapPassedString = "ok"_sr;
++ static constexpr Colour::Code tapDimColour = Colour::FileName;
++
++ class TapAssertionPrinter {
++ public:
++ TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
++ TapAssertionPrinter(TapAssertionPrinter const&) = delete;
++ TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
++ : stream(_stream)
++ , result(_stats.assertionResult)
++ , messages(_stats.infoMessages)
++ , itMessage(_stats.infoMessages.begin())
++ , printInfoMessages(true)
++ , counter(_counter)
++ , colourImpl( colour_ ) {}
++
++ void print() {
++ itMessage = messages.begin();
++
++ switch (result.getResultType()) {
++ case ResultWas::Ok:
++ printResultType(tapPassedString);
++ printOriginalExpression();
++ printReconstructedExpression();
++ if (!result.hasExpression())
++ printRemainingMessages(Colour::None);
++ else
++ printRemainingMessages();
++ break;
++ case ResultWas::ExpressionFailed:
++ if (result.isOk()) {
++ printResultType(tapPassedString);
++ } else {
++ printResultType(tapFailedString);
++ }
++ printOriginalExpression();
++ printReconstructedExpression();
++ if (result.isOk()) {
++ printIssue(" # TODO");
++ }
++ printRemainingMessages();
++ break;
++ case ResultWas::ThrewException:
++ printResultType(tapFailedString);
++ printIssue("unexpected exception with message:"_sr);
++ printMessage();
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::FatalErrorCondition:
++ printResultType(tapFailedString);
++ printIssue("fatal error condition with message:"_sr);
++ printMessage();
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::DidntThrowException:
++ printResultType(tapFailedString);
++ printIssue("expected exception, got none"_sr);
++ printExpressionWas();
++ printRemainingMessages();
++ break;
++ case ResultWas::Info:
++ printResultType("info"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ case ResultWas::Warning:
++ printResultType("warning"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ case ResultWas::ExplicitFailure:
++ printResultType(tapFailedString);
++ printIssue("explicitly"_sr);
++ printRemainingMessages(Colour::None);
++ break;
++ case ResultWas::ExplicitSkip:
++ printResultType(tapPassedString);
++ printIssue(" # SKIP"_sr);
++ printMessage();
++ printRemainingMessages();
++ break;
++ // These cases are here to prevent compiler warnings
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ printResultType("** internal error **"_sr);
++ break;
++ }
++ }
++
++ private:
++ void printResultType(StringRef passOrFail) const {
++ if (!passOrFail.empty()) {
++ stream << passOrFail << ' ' << counter << " -";
++ }
++ }
++
++ void printIssue(StringRef issue) const {
++ stream << ' ' << issue;
++ }
++
++ void printExpressionWas() {
++ if (result.hasExpression()) {
++ stream << ';';
++ stream << colourImpl->guardColour( tapDimColour )
++ << " expression was:";
++ printOriginalExpression();
++ }
++ }
++
++ void printOriginalExpression() const {
++ if (result.hasExpression()) {
++ stream << ' ' << result.getExpression();
++ }
++ }
++
++ void printReconstructedExpression() const {
++ if (result.hasExpandedExpression()) {
++ stream << colourImpl->guardColour( tapDimColour ) << " for: ";
++
++ std::string expr = result.getExpandedExpression();
++ std::replace(expr.begin(), expr.end(), '\n', ' ');
++ stream << expr;
++ }
++ }
++
++ void printMessage() {
++ if (itMessage != messages.end()) {
++ stream << " '" << itMessage->message << '\'';
++ ++itMessage;
++ }
++ }
++
++ void printRemainingMessages(Colour::Code colour = tapDimColour) {
++ if (itMessage == messages.end()) {
++ return;
++ }
++
++ // using messages.end() directly (or auto) yields compilation error:
++ std::vector<MessageInfo>::const_iterator itEnd = messages.end();
++ const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
++
++ stream << colourImpl->guardColour( colour ) << " with "
++ << pluralise( N, "message"_sr ) << ':';
++
++ for (; itMessage != itEnd; ) {
++ // If this assertion is a warning ignore any INFO messages
++ if (printInfoMessages || itMessage->type != ResultWas::Info) {
++ stream << " '" << itMessage->message << '\'';
++ if (++itMessage != itEnd) {
++ stream << colourImpl->guardColour(tapDimColour) << " and";
++ }
++ }
++ }
++ }
++
++ private:
++ std::ostream& stream;
++ AssertionResult const& result;
++ std::vector<MessageInfo> const& messages;
++ std::vector<MessageInfo>::const_iterator itMessage;
++ bool printInfoMessages;
++ std::size_t counter;
++ ColourImpl* colourImpl;
++ };
++
++ } // End anonymous namespace
++
++ void TAPReporter::testRunStarting( TestRunInfo const& ) {
++ if ( m_config->testSpec().hasFilters() ) {
++ m_stream << "# filters: " << m_config->testSpec() << '\n';
++ }
++ m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
++ }
++
++ void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
++ m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
++ }
++
++ void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
++ ++counter;
++
++ m_stream << "# " << currentTestCaseInfo->name << '\n';
++ TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
++ printer.print();
++
++ m_stream << '\n' << std::flush;
++ }
++
++ void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
++ m_stream << "1.." << _testRunStats.totals.assertions.total();
++ if (_testRunStats.totals.testCases.total() == 0) {
++ m_stream << " # Skipped: No tests ran.";
++ }
++ m_stream << "\n\n" << std::flush;
++ StreamingReporterBase::testRunEnded(_testRunStats);
++ }
++
++
++
++
++} // end namespace Catch
++
++
++
++
++#include <cassert>
++#include <ostream>
++
++namespace Catch {
++
++ namespace {
++ // if string has a : in first line will set indent to follow it on
++ // subsequent lines
++ void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
++ std::size_t i = _string.find(": ");
++ if (i != std::string::npos)
++ i += 2;
++ else
++ i = 0;
++ os << TextFlow::Column(_string)
++ .indent(indent + i)
++ .initialIndent(indent) << '\n';
++ }
++
++ std::string escape(StringRef str) {
++ std::string escaped = static_cast<std::string>(str);
++ replaceInPlace(escaped, "|", "||");
++ replaceInPlace(escaped, "'", "|'");
++ replaceInPlace(escaped, "\n", "|n");
++ replaceInPlace(escaped, "\r", "|r");
++ replaceInPlace(escaped, "[", "|[");
++ replaceInPlace(escaped, "]", "|]");
++ return escaped;
++ }
++ } // end anonymous namespace
++
++
++ TeamCityReporter::~TeamCityReporter() = default;
++
++ void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
++ m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
++ << "']\n";
++ }
++
++ void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
++ m_stream << "##teamcity[testSuiteFinished name='"
++ << escape( runStats.runInfo.name ) << "']\n";
++ }
++
++ void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
++ AssertionResult const& result = assertionStats.assertionResult;
++ if ( !result.isOk() ||
++ result.getResultType() == ResultWas::ExplicitSkip ) {
++
++ ReusableStringStream msg;
++ if (!m_headerPrintedForThisSection)
++ printSectionHeader(msg.get());
++ m_headerPrintedForThisSection = true;
++
++ msg << result.getSourceInfo() << '\n';
++
++ switch (result.getResultType()) {
++ case ResultWas::ExpressionFailed:
++ msg << "expression failed";
++ break;
++ case ResultWas::ThrewException:
++ msg << "unexpected exception";
++ break;
++ case ResultWas::FatalErrorCondition:
++ msg << "fatal error condition";
++ break;
++ case ResultWas::DidntThrowException:
++ msg << "no exception was thrown where one was expected";
++ break;
++ case ResultWas::ExplicitFailure:
++ msg << "explicit failure";
++ break;
++ case ResultWas::ExplicitSkip:
++ msg << "explicit skip";
++ break;
++
++ // We shouldn't get here because of the isOk() test
++ case ResultWas::Ok:
++ case ResultWas::Info:
++ case ResultWas::Warning:
++ CATCH_ERROR("Internal error in TeamCity reporter");
++ // These cases are here to prevent compiler warnings
++ case ResultWas::Unknown:
++ case ResultWas::FailureBit:
++ case ResultWas::Exception:
++ CATCH_ERROR("Not implemented");
++ }
++ if (assertionStats.infoMessages.size() == 1)
++ msg << " with message:";
++ if (assertionStats.infoMessages.size() > 1)
++ msg << " with messages:";
++ for (auto const& messageInfo : assertionStats.infoMessages)
++ msg << "\n \"" << messageInfo.message << '"';
++
++
++ if (result.hasExpression()) {
++ msg <<
++ "\n " << result.getExpressionInMacro() << "\n"
++ "with expansion:\n"
++ " " << result.getExpandedExpression() << '\n';
++ }
++
++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
++ m_stream << "##teamcity[testIgnored";
++ } else if ( currentTestCaseInfo->okToFail() ) {
++ msg << "- failure ignore as test marked as 'ok to fail'\n";
++ m_stream << "##teamcity[testIgnored";
++ } else {
++ m_stream << "##teamcity[testFailed";
++ }
++ m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
++ << " message='" << escape( msg.str() ) << '\'' << "]\n";
++ }
++ m_stream.flush();
++ }
++
++ void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
++ m_testTimer.start();
++ StreamingReporterBase::testCaseStarting(testInfo);
++ m_stream << "##teamcity[testStarted name='"
++ << escape(testInfo.name) << "']\n";
++ m_stream.flush();
++ }
++
++ void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
++ StreamingReporterBase::testCaseEnded(testCaseStats);
++ auto const& testCaseInfo = *testCaseStats.testInfo;
++ if (!testCaseStats.stdOut.empty())
++ m_stream << "##teamcity[testStdOut name='"
++ << escape(testCaseInfo.name)
++ << "' out='" << escape(testCaseStats.stdOut) << "']\n";
++ if (!testCaseStats.stdErr.empty())
++ m_stream << "##teamcity[testStdErr name='"
++ << escape(testCaseInfo.name)
++ << "' out='" << escape(testCaseStats.stdErr) << "']\n";
++ m_stream << "##teamcity[testFinished name='"
++ << escape(testCaseInfo.name) << "' duration='"
++ << m_testTimer.getElapsedMilliseconds() << "']\n";
++ m_stream.flush();
++ }
++
++ void TeamCityReporter::printSectionHeader(std::ostream& os) {
++ assert(!m_sectionStack.empty());
++
++ if (m_sectionStack.size() > 1) {
++ os << lineOfChars('-') << '\n';
++
++ std::vector<SectionInfo>::const_iterator
++ it = m_sectionStack.begin() + 1, // Skip first section (test case)
++ itEnd = m_sectionStack.end();
++ for (; it != itEnd; ++it)
++ printHeaderString(os, it->name);
++ os << lineOfChars('-') << '\n';
++ }
++
++ SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
++
++ os << lineInfo << '\n';
++ os << lineOfChars('.') << "\n\n";
++ }
++
++} // end namespace Catch
++
++
++
++
++#if defined(_MSC_VER)
++#pragma warning(push)
++#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
++ // Note that 4062 (not all labels are handled
++ // and default is missing) is enabled
++#endif
++
++namespace Catch {
++ XmlReporter::XmlReporter( ReporterConfig&& _config )
++ : StreamingReporterBase( CATCH_MOVE(_config) ),
++ m_xml(m_stream)
++ {
++ m_preferences.shouldRedirectStdOut = true;
++ m_preferences.shouldReportAllAssertions = true;
++ }
++
++ XmlReporter::~XmlReporter() = default;
++
++ std::string XmlReporter::getDescription() {
++ return "Reports test results as an XML document";
++ }
++
++ std::string XmlReporter::getStylesheetRef() const {
++ return std::string();
++ }
++
++ void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
++ m_xml
++ .writeAttribute( "filename"_sr, sourceInfo.file )
++ .writeAttribute( "line"_sr, sourceInfo.line );
++ }
++
++ void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
++ StreamingReporterBase::testRunStarting( testInfo );
++ std::string stylesheetRef = getStylesheetRef();
++ if( !stylesheetRef.empty() )
++ m_xml.writeStylesheetRef( stylesheetRef );
++ m_xml.startElement("Catch2TestRun")
++ .writeAttribute("name"_sr, m_config->name())
++ .writeAttribute("rng-seed"_sr, m_config->rngSeed())
++ .writeAttribute("xml-format-version"_sr, 3)
++ .writeAttribute("catch2-version"_sr, libraryVersion());
++ if ( m_config->testSpec().hasFilters() ) {
++ m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
++ }
++ }
++
++ void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
++ StreamingReporterBase::testCaseStarting(testInfo);
++ m_xml.startElement( "TestCase" )
++ .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
++ .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
++
++ writeSourceInfo( testInfo.lineInfo );
++
++ if ( m_config->showDurations() == ShowDurations::Always )
++ m_testCaseTimer.start();
++ m_xml.ensureTagClosed();
++ }
++
++ void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
++ StreamingReporterBase::sectionStarting( sectionInfo );
++ if( m_sectionDepth++ > 0 ) {
++ m_xml.startElement( "Section" )
++ .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
++ writeSourceInfo( sectionInfo.lineInfo );
++ m_xml.ensureTagClosed();
++ }
++ }
++
++ void XmlReporter::assertionStarting( AssertionInfo const& ) { }
++
++ void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
++
++ AssertionResult const& result = assertionStats.assertionResult;
++
++ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
++
++ if( includeResults || result.getResultType() == ResultWas::Warning ) {
++ // Print any info messages in <Info> tags.
++ for( auto const& msg : assertionStats.infoMessages ) {
++ if( msg.type == ResultWas::Info && includeResults ) {
++ auto t = m_xml.scopedElement( "Info" );
++ writeSourceInfo( msg.lineInfo );
++ t.writeText( msg.message );
++ } else if ( msg.type == ResultWas::Warning ) {
++ auto t = m_xml.scopedElement( "Warning" );
++ writeSourceInfo( msg.lineInfo );
++ t.writeText( msg.message );
++ }
++ }
++ }
++
++ // Drop out if result was successful but we're not printing them.
++ if ( !includeResults && result.getResultType() != ResultWas::Warning &&
++ result.getResultType() != ResultWas::ExplicitSkip ) {
++ return;
++ }
++
++ // Print the expression if there is one.
++ if( result.hasExpression() ) {
++ m_xml.startElement( "Expression" )
++ .writeAttribute( "success"_sr, result.succeeded() )
++ .writeAttribute( "type"_sr, result.getTestMacroName() );
++
++ writeSourceInfo( result.getSourceInfo() );
++
++ m_xml.scopedElement( "Original" )
++ .writeText( result.getExpression() );
++ m_xml.scopedElement( "Expanded" )
++ .writeText( result.getExpandedExpression() );
++ }
++
++ // And... Print a result applicable to each result type.
++ switch( result.getResultType() ) {
++ case ResultWas::ThrewException:
++ m_xml.startElement( "Exception" );
++ writeSourceInfo( result.getSourceInfo() );
++ m_xml.writeText( result.getMessage() );
++ m_xml.endElement();
++ break;
++ case ResultWas::FatalErrorCondition:
++ m_xml.startElement( "FatalErrorCondition" );
++ writeSourceInfo( result.getSourceInfo() );
++ m_xml.writeText( result.getMessage() );
++ m_xml.endElement();
++ break;
++ case ResultWas::Info:
++ m_xml.scopedElement( "Info" )
++ .writeText( result.getMessage() );
++ break;
++ case ResultWas::Warning:
++ // Warning will already have been written
++ break;
++ case ResultWas::ExplicitFailure:
++ m_xml.startElement( "Failure" );
++ writeSourceInfo( result.getSourceInfo() );
++ m_xml.writeText( result.getMessage() );
++ m_xml.endElement();
++ break;
++ case ResultWas::ExplicitSkip:
++ m_xml.startElement( "Skip" );
++ writeSourceInfo( result.getSourceInfo() );
++ m_xml.writeText( result.getMessage() );
++ m_xml.endElement();
++ break;
++ default:
++ break;
++ }
++
++ if( result.hasExpression() )
++ m_xml.endElement();
++ }
++
++ void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
++ StreamingReporterBase::sectionEnded( sectionStats );
++ if ( --m_sectionDepth > 0 ) {
++ {
++ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
++ e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
++ e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
++ e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
++ e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
++
++ if ( m_config->showDurations() == ShowDurations::Always )
++ e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
++ }
++ // Ends assertion tag
++ m_xml.endElement();
++ }
++ }
++
++ void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
++ StreamingReporterBase::testCaseEnded( testCaseStats );
++ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
++ e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
++ e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
++
++ if ( m_config->showDurations() == ShowDurations::Always )
++ e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
++ if( !testCaseStats.stdOut.empty() )
++ m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
++ if( !testCaseStats.stdErr.empty() )
++ m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
++
++ m_xml.endElement();
++ }
++
++ void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
++ StreamingReporterBase::testRunEnded( testRunStats );
++ m_xml.scopedElement( "OverallResults" )
++ .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
++ .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
++ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
++ .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
++ m_xml.scopedElement( "OverallResultsCases")
++ .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
++ .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
++ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
++ .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
++ m_xml.endElement();
++ }
++
++ void XmlReporter::benchmarkPreparing( StringRef name ) {
++ m_xml.startElement("BenchmarkResults")
++ .writeAttribute("name"_sr, name);
++ }
++
++ void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
++ m_xml.writeAttribute("samples"_sr, info.samples)
++ .writeAttribute("resamples"_sr, info.resamples)
++ .writeAttribute("iterations"_sr, info.iterations)
++ .writeAttribute("clockResolution"_sr, info.clockResolution)
++ .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
++ .writeComment("All values in nano seconds"_sr);
++ }
++
++ void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
++ m_xml.scopedElement("mean")
++ .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
++ .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
++ .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
++ .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
++ m_xml.scopedElement("standardDeviation")
++ .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
++ .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
++ .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
++ .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
++ m_xml.scopedElement("outliers")
++ .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
++ .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
++ .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
++ .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
++ .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
++ m_xml.endElement();
++ }
++
++ void XmlReporter::benchmarkFailed(StringRef error) {
++ m_xml.scopedElement("failed").
++ writeAttribute("message"_sr, error);
++ m_xml.endElement();
++ }
++
++ void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
++ auto outerTag = m_xml.scopedElement("AvailableReporters");
++ for (auto const& reporter : descriptions) {
++ auto inner = m_xml.scopedElement("Reporter");
++ m_xml.startElement("Name", XmlFormatting::Indent)
++ .writeText(reporter.name, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ m_xml.startElement("Description", XmlFormatting::Indent)
++ .writeText(reporter.description, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ }
++ }
++
++ void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
++ auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
++ for ( auto const& listener : descriptions ) {
++ auto inner = m_xml.scopedElement( "Listener" );
++ m_xml.startElement( "Name", XmlFormatting::Indent )
++ .writeText( listener.name, XmlFormatting::None )
++ .endElement( XmlFormatting::Newline );
++ m_xml.startElement( "Description", XmlFormatting::Indent )
++ .writeText( listener.description, XmlFormatting::None )
++ .endElement( XmlFormatting::Newline );
++ }
++ }
++
++ void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
++ auto outerTag = m_xml.scopedElement("MatchingTests");
++ for (auto const& test : tests) {
++ auto innerTag = m_xml.scopedElement("TestCase");
++ auto const& testInfo = test.getTestCaseInfo();
++ m_xml.startElement("Name", XmlFormatting::Indent)
++ .writeText(testInfo.name, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ m_xml.startElement("ClassName", XmlFormatting::Indent)
++ .writeText(testInfo.className, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ m_xml.startElement("Tags", XmlFormatting::Indent)
++ .writeText(testInfo.tagsAsString(), XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++
++ auto sourceTag = m_xml.scopedElement("SourceInfo");
++ m_xml.startElement("File", XmlFormatting::Indent)
++ .writeText(testInfo.lineInfo.file, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ m_xml.startElement("Line", XmlFormatting::Indent)
++ .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ }
++ }
++
++ void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
++ auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
++ for (auto const& tag : tags) {
++ auto innerTag = m_xml.scopedElement("Tag");
++ m_xml.startElement("Count", XmlFormatting::Indent)
++ .writeText(std::to_string(tag.count), XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ auto aliasTag = m_xml.scopedElement("Aliases");
++ for (auto const& alias : tag.spellings) {
++ m_xml.startElement("Alias", XmlFormatting::Indent)
++ .writeText(alias, XmlFormatting::None)
++ .endElement(XmlFormatting::Newline);
++ }
++ }
++ }
++
++} // end namespace Catch
++
++#if defined(_MSC_VER)
++#pragma warning(pop)
++#endif
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/multi_accept.cpp
+@@ -0,0 +1,129 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim::asio;
++using namespace sim::chrono;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++namespace {
++
++int num_incoming = 0;
++int num_connected = 0;
++
++int counter = 0;
++
++void incoming_connection(boost::system::error_code const& ec
++ , ip::tcp::socket& sock, ip::tcp::acceptor& listener)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while accepting connection: %s\n"
++ , millis, ec.message().c_str());
++ return;
++ }
++
++ ++num_incoming;
++
++ std::printf("[%4d] received incoming connection\n", millis);
++ sock.close();
++
++ listener.async_accept(sock, std::bind(&incoming_connection
++ , _1, std::ref(sock), std::ref(listener)));
++}
++
++void on_connected(boost::system::error_code const& ec
++ , ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ ++num_connected;
++
++ std::printf("[%4d] made outgoing connection\n", millis);
++ sock.close();
++
++ if (++counter > 5) return;
++
++ boost::system::error_code err;
++ sock.open(ip::tcp::v4(), err);
++ if (err) std::printf("[%4d] open failed: %s\n", millis, err.message().c_str());
++ sock.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
++ , 1337), std::bind(&on_connected, _1, std::ref(sock)));
++}
++
++}
++
++TEST_CASE("accept a connection multiple times on the same socket", "[accept]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
++ ip::tcp::acceptor listener(incoming_ios);
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ boost::system::error_code ec;
++ listener.open(ip::tcp::v4(), ec);
++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
++ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
++ listener.listen(10, ec);
++ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
++
++ ip::tcp::socket incoming(incoming_ios);
++ listener.async_accept(incoming
++ , std::bind(&incoming_connection, _1, std::ref(incoming)
++ , std::ref(listener)));
++
++ std::printf("[%4d] connecting\n", millis);
++ ip::tcp::socket outgoing(outgoing_ios);
++ outgoing.open(ip::tcp::v4(), ec);
++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
++
++ sim.run();
++
++ CHECK(num_incoming == 6);
++ CHECK(num_connected == 6);
++
++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/multi_homed.cpp
+@@ -0,0 +1,212 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim;
++using namespace sim::asio::ip;
++using namespace sim::chrono;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++namespace {
++
++char receive_buf[1000];
++char send_buf[1000];
++
++int num_ipv6 = 0;
++int num_ipv4 = 0;
++
++}
++
++void on_receive(boost::system::error_code const& ec, std::size_t /* bytes_transferred */
++ , udp::socket& s)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ if (ec)
++ {
++ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ std::printf("[%4d] received packet on %s\n", millis,
++ s.local_endpoint().address().to_string().c_str());
++
++ if (s.local_endpoint().address().is_v4())
++ {
++ ++num_ipv4;
++ }
++ else
++ {
++ ++num_ipv6;
++ }
++}
++
++TEST_CASE("one node can have multiple addresses (UDP)", "[multi-homed]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++
++ // the machine receiving packets has two IP addresses
++ asio::io_context incoming_ios(sim, {
++ make_address_v4("40.30.20.10"),
++ make_address_v6("ff::dead:beef:1337")} );
++ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
++
++ // we create two sockets for it, one for each interface
++ udp::socket incoming_v4(incoming_ios);
++ udp::socket incoming_v6(incoming_ios);
++ udp::socket outgoing(outgoing_ios);
++
++ boost::system::error_code ec;
++ incoming_v4.open(udp::v4(), ec);
++ REQUIRE(!ec);
++ incoming_v4.bind(udp::endpoint(make_address_v4("40.30.20.10"), 1337), ec);
++ REQUIRE(!ec);
++ incoming_v4.async_receive(asio::buffer(receive_buf
++ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
++ , std::ref(incoming_v4)));
++
++ incoming_v6.open(udp::v6(), ec);
++ REQUIRE(!ec);
++ incoming_v6.bind(udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), ec);
++ REQUIRE(!ec);
++ incoming_v6.async_receive(asio::buffer(receive_buf
++ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
++ , std::ref(incoming_v6)));
++
++ outgoing.open(udp::v4(), ec);
++ REQUIRE(!ec);
++
++ outgoing.non_blocking(true);
++ REQUIRE(!ec);
++
++ // send a packet to the IPv4 address
++ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
++ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec);
++ REQUIRE(!ec);
++
++ // and a packet to the IPv6 address
++ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
++ , udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), 0, ec);
++ REQUIRE(!ec);
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ CHECK(millis == 43);
++ CHECK(num_ipv4 == 1);
++ CHECK(num_ipv6 == 1);
++}
++
++TEST_CASE("one node can have multiple addresses (TCP)", "[multi-homed]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++
++ const unsigned short listen_port = 4242;
++
++ // the machine receiving packets has two IP addresses
++ asio::io_context incoming_ios(sim, {
++ make_address_v4("40.30.20.10"),
++ make_address_v6("ff::dead:beef:1337")} );
++
++ // the machine sending packets has two IP addresses
++ asio::io_context outgoing_ios(sim, {
++ make_address_v4("10.20.30.40"),
++ make_address_v6("ff::abad:cafe:1337")
++ });
++
++ // we create two acceptors for it, one for each interface
++ asio::ip::tcp::acceptor incoming_v4(incoming_ios);
++ asio::ip::tcp::acceptor incoming_v6(incoming_ios);
++
++ tcp::socket outgoing_v4(outgoing_ios);
++ tcp::socket outgoing_v6(outgoing_ios);
++
++ boost::system::error_code ec;
++
++ incoming_v4.open(tcp::v4(), ec);
++ REQUIRE(!ec);
++ incoming_v4.bind(tcp::endpoint(address_v4::any(), listen_port));
++ REQUIRE(!ec);
++ incoming_v4.listen();
++
++ incoming_v6.open(tcp::v6(), ec);
++ REQUIRE(!ec);
++ incoming_v6.bind(tcp::endpoint(address_v6::any(), listen_port));
++ REQUIRE(!ec);
++ incoming_v6.listen();
++
++ int num_incoming_v4 = 0;
++ int num_incoming_v6 = 0;
++
++ tcp::socket incoming_socket(incoming_ios);
++ incoming_v4.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
++ REQUIRE(!ec);
++ CHECK(incoming_socket.remote_endpoint().address() == make_address_v4("10.20.30.40"));
++ num_incoming_v4++;
++ incoming_socket.close();
++ });
++
++ incoming_v6.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
++ REQUIRE(!ec);
++ CHECK(incoming_socket.remote_endpoint().address() == make_address_v6("ff::abad:cafe:1337"));
++ num_incoming_v6++;
++ incoming_socket.close();
++ });
++
++ // connect via ipv4
++ outgoing_v4.open(tcp::v4(), ec);
++ REQUIRE(!ec);
++ auto endpoint_v4 = asio::ip::tcp::endpoint(asio::ip::make_address("40.30.20.10"), listen_port);
++ outgoing_v4.async_connect(endpoint_v4, [] (boost::system::error_code ec) {
++ REQUIRE(!ec);
++ });
++ sim.run();
++
++ CHECK(num_incoming_v4 == 1);
++ CHECK(num_incoming_v6 == 0);
++
++ // connect via ipv6
++ outgoing_v6.open(tcp::v6(), ec);
++ REQUIRE(!ec);
++ auto endpoint_v6 = asio::ip::tcp::endpoint(asio::ip::make_address("ff::dead:beef:1337"), listen_port);
++ outgoing_v6.async_connect(endpoint_v6, [] (boost::system::error_code ec) {
++ REQUIRE(!ec);
++ });
++
++ sim.run();
++
++ CHECK(num_incoming_v4 == 1);
++ CHECK(num_incoming_v6 == 1);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/null_buffers.cpp
+@@ -0,0 +1,200 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim::asio;
++using namespace sim::chrono;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++char send_buffer[10000];
++char recv_buffer[10000];
++int num_received = 0;
++int num_sent = 0;
++
++void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
++ , ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ num_sent += int(bytes_transferred);
++ std::printf("[%4d] sent %d bytes (total: %d)\n"
++ , millis, int(bytes_transferred), num_sent);
++
++ if (num_sent < 1000000)
++ {
++ sock.async_write_some(sim::asio::buffer(send_buffer
++ , (std::min)(1000000 - num_sent, int(sizeof(send_buffer))))
++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
++ return;
++ }
++ std::printf("closing\n");
++ sock.close();
++}
++
++void on_receive(boost::system::error_code const& ec, ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ boost::system::error_code err;
++ std::size_t bytes_transferred = sock.read_some(sim::asio::buffer(
++ recv_buffer, sizeof(recv_buffer)), err);
++ if (err && err != boost::system::error_code(error::would_block))
++ {
++ std::printf("[%4d] receive error %s\n", millis, err.message().c_str());
++ return;
++ }
++
++ num_received += int(bytes_transferred);
++
++ std::printf("[%4d] received %d bytes (total: %d)\n"
++ , millis, int(bytes_transferred), num_received);
++
++ sock.async_wait(ip::tcp::socket::wait_read
++ , std::bind(&on_receive, _1, std::ref(sock)));
++}
++
++void incoming_connection(boost::system::error_code const& ec
++ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while accepting connection: %s\n"
++ , millis, ec.message().c_str());
++ return;
++ }
++
++ boost::system::error_code err;
++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
++ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
++ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
++ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
++ , millis, ep.address().to_string().c_str(), ep.port()
++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
++ CHECK(local_endpoint.port() == 1337);
++ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
++ CHECK(remote_endpoint.port() != 0);
++ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
++
++ sock.non_blocking(true);
++ if (err) std::printf("[%4d] ioctl failed: %s\n", millis, err.message().c_str());
++
++ sock.async_wait(ip::tcp::socket::wait_read
++ , std::bind(&on_receive, _1, std::ref(sock)));
++}
++
++void on_connected(boost::system::error_code const& ec
++ , ip::tcp::socket& sock)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ if (ec)
++ {
++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ boost::system::error_code err;
++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
++ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
++ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
++ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
++ , millis
++ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
++
++ CHECK(remote_endpoint.port() == 1337);
++ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
++ CHECK(local_endpoint.port() != 0);
++ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
++
++ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
++ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
++}
++
++TEST_CASE("receive null_buffers", "[null_buffers]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
++ ip::tcp::acceptor listener(incoming_ios);
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ boost::system::error_code ec;
++ listener.open(ip::tcp::v4(), ec);
++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
++ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
++ listener.listen(10, ec);
++ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
++
++ dump_network_graph(sim, "null_buffers.dot");
++
++ ip::tcp::socket incoming(incoming_ios);
++ ip::tcp::endpoint remote_endpoint;
++ listener.async_accept(incoming, remote_endpoint
++ , std::bind(&incoming_connection, _1, std::ref(incoming)
++ , std::cref(remote_endpoint)));
++
++ std::printf("[%4d] connecting\n", millis);
++ ip::tcp::socket outgoing(outgoing_ios);
++ outgoing.open(ip::tcp::v4(), ec);
++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
++
++ sim.run();
++
++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++ std::printf("num_sent: %d num_received: %d\n"
++ , num_sent, num_received);
++
++ CHECK(num_received == num_sent);
++ CHECK(num_received == 1000000);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/parse_request.cpp
+@@ -0,0 +1,76 @@
++/*
++
++Copyright (c) 2017, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++#include "simulator/http_server.hpp" // for parse_request
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++TEST_CASE("parse GET request", "[parse_request]")
++{
++ auto str = "GET /foo/bar?x=4 HTTP/1.1\r\n\r\n";
++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
++ CHECK(req.method == "GET");
++ CHECK(req.req == "/foo/bar?x=4");
++ CHECK(req.path == "/foo/bar");
++ CHECK(req.headers.empty());
++}
++
++TEST_CASE("request path is normalized (no leading slash)", "[parse_request]")
++{
++ auto str = "GET foo/bar HTTP/1.1\r\n\r\n";
++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
++ CHECK(req.path == "/foo/bar");
++}
++
++TEST_CASE("request path is normalized (..)", "[parse_request]")
++{
++ auto str = "GET /foo/../foo/bar HTTP/1.1\r\n\r\n";
++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
++ CHECK(req.path == "/foo/bar");
++}
++
++TEST_CASE("parse CONNECT request", "[parse_request]")
++{
++ auto str = "CONNECT 192.168.0.1:8888 HTTP/1.1\r\n\r\n";
++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
++ CHECK(req.method == "CONNECT");
++ CHECK(req.req == "192.168.0.1:8888");
++ CHECK(req.path == "192.168.0.1:8888");
++ CHECK(req.headers.empty());
++}
++
++TEST_CASE("headers are parsed", "[parse_request]")
++{
++ auto str = "GET / HTTP/1.1\r\nX-Foo: Bar\r\n\r\n";
++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
++ CHECK(!req.headers.empty());
++ CHECK(req.headers["x-foo"] == "Bar");
++}
++
++TEST_CASE("invalid formed request throws parse exception", "[parse_request]")
++{
++ auto str = "INVALID";
++ REQUIRE_THROWS_WITH(sim::parse_request(str, static_cast<int>(std::strlen(str))), Catch::Matchers::ContainsSubstring("parse failed"));
++}
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/resolver.cpp
+@@ -0,0 +1,192 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace std::placeholders;
++using namespace sim;
++
++using asio::ip::make_address_v4;
++using asio::ip::address_v4;
++using duration = chrono::high_resolution_clock::duration;
++using chrono::duration_cast;
++using chrono::milliseconds;
++
++int num_lookups = 0;
++
++void on_name_lookup(boost::system::error_code const& /* ec */
++ , asio::ip::tcp::resolver::results_type ips)
++{
++ ++num_lookups;
++
++ std::vector<address_v4> expect = {
++ make_address_v4("1.2.3.4")
++ , make_address_v4("1.2.3.5")
++ , make_address_v4("1.2.3.6")
++ , make_address_v4("1.2.3.7") };
++
++ auto expect_it = expect.begin();
++
++ for (auto const& ip : ips)
++ {
++ assert(ip.endpoint().address() == *expect_it);
++ assert(ip.endpoint().port() == 8080);
++
++ ++expect_it;
++ }
++
++ assert(expect_it == expect.end());
++}
++
++void on_failed_name_lookup(boost::system::error_code const& ec
++ , asio::ip::tcp::resolver::results_type /* ips */)
++{
++ ++num_lookups;
++
++ assert(ec == boost::system::error_code(asio::error::host_not_found));
++}
++
++struct sim_config : sim::default_config
++{
++ duration hostname_lookup(
++ asio::ip::address const& requestor
++ , std::string hostname
++ , std::vector<asio::ip::address>& result
++ , boost::system::error_code& ec)
++ {
++ if (hostname == "test.com")
++ {
++ result = {
++ make_address_v4("1.2.3.4")
++ , make_address_v4("1.2.3.5")
++ , make_address_v4("1.2.3.6")
++ , make_address_v4("1.2.3.7")
++ };
++ return duration_cast<duration>(chrono::milliseconds(50));
++ }
++
++ return default_config::hostname_lookup(requestor, hostname, result, ec);
++ }
++};
++
++TEST_CASE("resolve multiple IPv4 addresses", "[resolver]") {
++ sim_config cfg;
++ simulation sim(cfg);
++
++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
++ num_lookups = 0;
++
++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
++
++ asio::ip::tcp::resolver resolver(ios);
++ resolver.async_resolve("test.com", "8080"
++ , std::bind(&on_name_lookup, _1, _2));
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
++
++ CHECK(millis == 50);
++ CHECK(num_lookups == 1);
++}
++
++TEST_CASE("resolve non-existent hostname", "[resolver]") {
++ sim_config cfg;
++ simulation sim(cfg);
++
++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
++ num_lookups = 0;
++
++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
++
++ asio::ip::tcp::resolver resolver(ios);
++ resolver.async_resolve("non-existent.com", "8080"
++ , std::bind(&on_failed_name_lookup, _1, _2));
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
++
++ CHECK(millis == 100);
++ CHECK(num_lookups == 1);
++}
++
++TEST_CASE("lookups resolve serially, compounding the latency", "[resolver]") {
++ sim_config cfg;
++ simulation sim(cfg);
++
++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
++ num_lookups = 0;
++
++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
++
++ asio::ip::tcp::resolver resolver(ios);
++ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
++ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
++
++ CHECK(millis == 200);
++ CHECK(num_lookups == 2);
++}
++
++TEST_CASE("resolve an IP address", "[resolver]") {
++ sim_config cfg;
++ simulation sim(cfg);
++
++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
++ num_lookups = 0;
++
++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
++
++ asio::ip::tcp::resolver resolver(ios);
++ resolver.async_resolve("10.10.10.10", "8080"
++ , [](boost::system::error_code const& /* ec */, asio::ip::tcp::resolver::results_type ips)
++ {
++ ++num_lookups;
++ std::vector<address_v4> expect = { make_address_v4("10.10.10.10") };
++
++ auto expect_it = expect.begin();
++ for (auto const& ip : ips)
++ {
++ assert(ip.endpoint().address() == *expect_it);
++ assert(ip.endpoint().port() == 8080);
++ ++expect_it;
++ }
++
++ assert(expect_it == expect.end());
++ });
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
++
++ CHECK(millis == 0);
++ CHECK(num_lookups == 1);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/timer.cpp
+@@ -0,0 +1,91 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim::chrono;
++using namespace sim::asio;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++namespace {
++
++ int counter = 0;
++ const int expected_timestamps[] = {1000, 2000, 4000, 7000, 11000 };
++
++ high_resolution_clock::time_point start;
++}
++
++void print_time(high_resolution_timer& timer
++ , boost::system::error_code const& ec)
++{
++ using namespace sim::chrono;
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now() - start).count());
++
++ std::printf("[%d] timer fired at: %d milliseconds. error: %s\n"
++ , counter
++ , millis
++ , ec.message().c_str());
++
++ if (ec)
++ {
++ CHECK(millis == 0);
++ return;
++ }
++
++ CHECK(millis == expected_timestamps[counter]);
++
++ ++counter;
++ if (counter < 5)
++ {
++ timer.expires_after(seconds(counter));
++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
++ }
++}
++
++TEST_CASE("wait for timers", "[timer]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++ io_context ios(sim, ip::make_address_v4("1.2.3.4"));
++ high_resolution_timer timer(ios);
++
++ start = high_resolution_clock::now();
++
++ timer.expires_after(seconds(10));
++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
++
++ timer.cancel();
++ timer.expires_after(seconds(1));
++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
++
++ sim.run();
++
++ CHECK(counter == 5);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/udp_socket.cpp
+@@ -0,0 +1,114 @@
++/*
++
++Copyright (c) 2015, Arvid Norberg
++All rights reserved.
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++*/
++
++#include "simulator/simulator.hpp"
++#include <functional>
++#include <cstdio> // for printf
++#include "catch.hpp"
++
++#ifdef __GNUC__
++// for CATCH's CHECK macro
++#pragma GCC diagnostic ignored "-Wparentheses"
++#endif
++
++using namespace sim;
++using namespace sim::asio::ip;
++using namespace sim::chrono;
++using sim::simulation;
++using sim::default_config;
++using namespace std::placeholders;
++
++namespace {
++
++char receive_buf[1000];
++char send_buf[1000];
++
++int num_sent = 0;
++int num_received = 0;
++
++void on_receive(boost::system::error_code const& ec, std::size_t bytes_transferred
++ , udp::socket& s, udp::endpoint& ep)
++{
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ if (ec)
++ {
++ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
++ return;
++ }
++
++ num_received += int(bytes_transferred);
++
++ std::printf("[%4d] received %d bytes from %s\n", millis
++ , int(bytes_transferred)
++ , ep.address().to_string().c_str());
++
++ if (bytes_transferred == 100 * 10) return;
++
++ s.async_receive_from(asio::buffer(receive_buf
++ , sizeof(receive_buf)), ep, std::bind(&on_receive, _1, _2
++ , std::ref(s), std::ref(ep)));
++}
++
++}
++
++TEST_CASE("send packet to udp socket", "[udp_socket]")
++{
++ default_config cfg;
++ simulation sim(cfg);
++ asio::io_context incoming_ios(sim, make_address_v4("40.30.20.10"));
++ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
++
++ udp::socket incoming(incoming_ios);
++ udp::socket outgoing(outgoing_ios);
++
++ boost::system::error_code ec;
++ incoming.open(udp::v4(), ec);
++ REQUIRE(!ec);
++ incoming.bind(udp::endpoint(address(), 1337), ec);
++ REQUIRE(!ec);
++
++ outgoing.open(udp::v4(), ec);
++ REQUIRE(!ec);
++
++ udp::endpoint remote_endpoint;
++ incoming.async_receive_from(asio::buffer(receive_buf,
++ sizeof(receive_buf)), remote_endpoint, std::bind(&on_receive, _1, _2
++ , std::ref(incoming), std::ref(remote_endpoint)));
++
++ outgoing.non_blocking(true);
++ REQUIRE(!ec);
++
++ for (int i = 1; i < 10; ++i)
++ {
++ num_sent += int(outgoing.send_to(asio::buffer(send_buf, 100 * i)
++ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec));
++ REQUIRE(!ec);
++ }
++
++ sim.run();
++
++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
++ .time_since_epoch()).count());
++
++ CHECK(millis == 56);
++ CHECK(num_sent == num_received);
++ CHECK(num_sent == 100 * 45);
++}
++
+--- /dev/null
++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/user-config.jam
+@@ -0,0 +1,3 @@
++using msvc : 14.1 ;
++using gcc ;
++
projects / libtorrent-rasterbar.git / commitdiff